1 # AliRoot Build System Utility Macro and Function definitions
3 # Author: Johny Jose (johny.jose@cern.ch)
4 # Port of previous Makefile build to cmake
6 cmake_minimum_required(VERSION 2.8 FATAL_ERROR)
8 macro(ALICE_DevFlagsOutput)
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")
21 endmacro(ALICE_DevFlagsOutput)
23 function(ALICE_CleanOutput _output input)
25 string(REGEX REPLACE "\n" " " clean ${input})
26 set(${_output} ${clean} PARENT_SCOPE)
28 endfunction(ALICE_CleanOutput)
30 function(ALICE_CorrectPaths _output value )
33 foreach(path ${value})
35 string(REGEX MATCH "^/" external ${path})
37 list(APPEND corrected "${CMAKE_SOURCE_DIR}/${path}" )
39 list(APPEND corrected ${path})
42 set(${_output} ${corrected} PARENT_SCOPE)
44 endfunction(ALICE_CorrectPaths)
46 function(ALICE_Format _output prefix suffix input)
48 # DevNotes - input should be put in quotes or the complete list does not get passed to the function
53 string(REGEX MATCH "^${prefix}" pre ${arg})
56 string(REGEX MATCH "${suffix}$" suf ${arg})
59 set(item "${prefix}${item}")
62 set(item "${item}${suffix}")
64 list(APPEND format ${item})
66 set(${_output} ${format} PARENT_SCOPE)
68 endfunction(ALICE_Format)
70 function(ALICE_CheckLibraries _output input)
75 string(REGEX MATCH "^(/|-)" preformatted ${item})
78 endif(NOT preformatted)
79 list(APPEND format ${item})
81 set(${_output} ${format} PARENT_SCOPE)
83 endfunction(ALICE_CheckLibraries)
85 function(ALICE_RootConfig _output parameters)
88 execute_process(COMMAND ${ROOT_CONFIG} ${parameters} OUTPUT_VARIABLE result ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE )
90 message(FATAL_ERROR "root-config ERROR : ${error}")
92 ALICE_CleanOutput(result "${result}")
93 set(${_output} "${result}" PARENT_SCOPE)
95 message(FATAL_ERROR "root-config not found")
98 endfunction(ALICE_RootConfig)
100 macro(ALICE_CheckOutOfSourceBuild)
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)
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)
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})
116 endmacro(ALICE_CheckOutOfSourceBuild)
118 macro(ALICE_ConfigureCompiler)
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")
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")
145 ALICE_RootConfig(RCFLAGS --auxcflags)
146 ALICE_RootConfig(RLFLAGS --ldflags)
148 set(CXXFLAGS "${CXXFLAGS} ${RCFLAGS}")
149 set(CFLAGS "${CFLAGS} ${RCFLAGS}")
150 set(SOFLAGS "${SOFLAGS} ${RLFLAGS}")
151 set(LDFLAGS "${LDFLAGS} ${RLFLAGS}")
153 if(NOT ALICXXWARN STREQUAL "NO")
154 set(CXXFLAGS "${CXXFLAGS} ${CXXWARN}")
155 endif(NOT ALICXXWARN STREQUAL "NO")
157 set(CXXFLAGS "${DATEFLAGS} ${CXXFLAGS}")
158 set(CFLAGS "${DATEFLAGS} ${CFLAGS}")
159 set(CINTFLAGS "${DATEFLAGS}")
161 endmacro(ALICE_ConfigureCompiler)
163 macro(ALICE_ConfigurePlatform)
166 include("CMake${ALICE_TARGET}")
168 endmacro(ALICE_ConfigurePlatform)
170 macro(ALICE_GetTarget)
172 #Set ALICE_TARGET if it has not been set yet
174 set(ALICE_TARGET $ENV{ALICE_TARGET})
175 #If ALICE_TARGET is not defined assign default values
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)
183 endmacro(ALICE_GetTarget)
185 macro(ALICE_ResetPackage)
187 set(MODDIR ${MODULE})
188 set(MODDIRI ${PROJECT_SOURCE_DIR}/${MODULE})
249 endmacro(ALICE_ResetPackage)
251 function(ALICE_SetPackageVariable _var ext setvalue unsetvalue )
253 #DevNotes - setvalue and unsetcalue should both be put in quotes or cmake throws an error if they have undefined values
255 set(${_var} ${setvalue} PARENT_SCOPE)
256 set(${PACKAGE}${ext} ${setvalue} PARENT_SCOPE)
258 set(${_var} ${unsetvalue} PARENT_SCOPE)
259 set(${PACKAGE}${ext} ${unsetvalue} PARENT_SCOPE)
262 endfunction(ALICE_SetPackageVariable)
264 macro(ALICE_BuildPackage)
266 list(APPEND EINCLUDE STEER)
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}")
277 if(DHDR OR CINTAUTOLINK)
279 endif(DHDR OR CINTAUTOLINK)
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}")
288 ALICE_SetPackageVariable(PCS "CS" "${CSRCS}" "${CSRCS}")
289 ALICE_SetPackageVariable(PCH "CH" "${CHDRS}" "${CHDRS}")
291 ALICE_SetPackageVariable(PFS "FS" "${FSRCS}" "${FSRCS}")
293 ALICE_SetPackageVariable(PS "S" "${SRCS}" "${SRCS}")
294 ALICE_SetPackageVariable(PH "H" "${HDRS} ${EHDRS}" "${HDRS} ${EHDRS}")
295 ALICE_SetPackageVariable(PCINTHDRS "CINTHDRS" "${CINTHDRS}" "${PH}")
297 string( REPLACE ".h" "" PCINTCLASSES "${PCINTHDRS}")
298 set ( ${PACKAGE}CINTCLASSES ${PCINTCLASSES})
300 ALICE_SetPackageVariable(PDH "DH" "${DHDR}" "")
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()
309 list(APPEND ${MODULE}LIBS ${PACKAGE})
310 list(APPEND ALLLIBS ${PACKAGE})
311 list(APPEND ${MODULE}ALIBS ${PACKAGE}_a)
312 list(APPEND ALLALIBS ${PACKAGE}_a)
313 list(APPEND BINLIBS ${PACKAGE})
315 list(APPEND ALLEXECS ${PACKAGE})
318 list(APPEND INCLUDEFILES ${PEXPORTDEST})
321 ALICE_SetPackageVariable(PDS "DS" "G__${PACKAGE}.cxx" "G__${PACKAGE}.cxx")
322 ALICE_GenerateDictionary()
325 message(STATUS "No dictionary generated for ${PACKAGE}")
333 ALICE_BuildExecutable()
335 endif(PS OR PCS OR PFS)
337 endmacro(ALICE_BuildPackage)
340 macro(ALICE_BuildModule)
342 add_definitions(-D_MODULE="${MODULE}")
343 foreach(PACKAGEFILE ${PACKAGES})
346 string(REGEX MATCH "CMakelib" lib ${PACKAGEFILE})
347 string(REGEX MATCH "CMakebin" bin ${PACKAGEFILE})
348 get_filename_component(PACKAGE ${PACKAGEFILE} NAME)
349 string(REGEX REPLACE "^CMake(lib|bin)(.*)\\.pkg" "\\2" PACKAGE ${PACKAGE})
351 message("Adding package ${PACKAGE} in ${MODULE}")
354 include(${PACKAGEFILE})
357 get_property(EXCLUDEPACKAGE TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL)
358 if(NOT EXCLUDEPACKAGE)
359 install(TARGETS ${PACKAGE}
360 RUNTIME DESTINATION bin
361 LIBRARY DESTINATION lib
362 ARCHIVE DESTINATION bin)
363 endif(NOT EXCLUDEPACKAGE)
364 endforeach(PACKAGEFILE)
366 endmacro(ALICE_BuildModule)
368 macro(ALICE_GenerateDictionary)
370 if(ALICEDEV STREQUAL "YES")
371 message("Generating Dictionary rule for ${PACKAGE}")
372 message("${ROOTCINT} -f ${PDS} -c ${PEDEFINE} ${CINTFLAGS} ${PINC} ${PCINTHDRS} ${PDH}")
373 endif(ALICEDEV STREQUAL "YES")
375 # Split up all arguments
377 set(DEDEFINE ${PEDEFINE})
378 set(DCINTFLAGS ${CINTFLAGS})
380 set(DCINTHDRS ${PCINTHDRS})
382 separate_arguments(DEDEFINE)
383 separate_arguments(DCINTFLAGS)
384 separate_arguments(DINC)
385 separate_arguments(DCINTHDRS)
386 separate_arguments(DDH)
387 # Format neccesary arguments
388 ALICE_Format(DINC "-I" "" "${DINC};${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
389 set_source_files_properties(${PDS} PROPERTIES GENERATED TRUE)
390 add_custom_command(OUTPUT ${PDS}
391 COMMAND cd ${PROJECT_SOURCE_DIR} && ${ROOTCINT} -f ${CMAKE_CURRENT_BINARY_DIR}/${PDS} -c -D_MODULE=\\\"${MODULE}\\\" ${DEDEFINE} ${DCINTFLAGS} ${DINC} ${DCINTHDRS} ${DDH}
392 WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
393 DEPENDS ${DCINTHDRS} ${DDH}
395 add_custom_target(G${PACKAGE})
396 add_dependencies(G${PACKAGE} ${PDS})
398 endmacro(ALICE_GenerateDictionary)
400 macro(ALICE_BuildLibrary)
402 ALICE_DevFlagsOutput()
403 set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS}")
404 set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS}")
405 set(CMAKE_Fortran_FLAGS ${PEDEFINE} ${PFFLAGS})
406 set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
407 set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
410 separate_arguments(PINC)
411 separate_arguments(EINCLUDE)
412 separate_arguments(PELIBSDIR)
413 separate_arguments(PBLIBS)
414 separate_arguments(PELIBS)
415 separate_arguments(SHLIB)
417 ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
418 ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
419 ALICE_CheckLibraries(PELIBS "${PELIBS}")
421 ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
422 ALICE_CorrectPaths(PINC "${PINC}")
424 include_directories(SYSTEM ${ROOTINCDIR})
425 include_directories(${PINC})
426 include_directories(${EINCLUDE})
427 include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
429 add_library(${PACKAGE} SHARED ${PCS} ${PFS} ${PS} ${PDS})
433 target_link_libraries(${PACKAGE} ${PELIBSDIR} ${PELIBS} ${SHLIB})
434 endif(PELIBS OR SHLIB)
436 add_dependencies(${MODULE}-all ${PACKAGE})
438 add_library(${PACKAGE}_a STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS})
440 target_link_libraries(${PACKAGE}_a ${PELIBSDIR} ${PELIBS} ${ALLIB})
441 endif(PELIBS OR ALLIB)
443 add_dependencies(${MODULE}-static ${PACKAGE}_a)
444 if(ALIPROFILE STREQUAL "YES")
445 add_dependencies(${MODULE}-all ${MODULE}-static)
446 endif(ALIPROFILE STREQUAL "YES")
448 list(FIND EXCLUDEMODULES ${MODULE} RESULT)
449 if(NOT RESULT STREQUAL "-1")
450 message(STATUS "${MODULE} will not be built by default. Type make ${MODULE}-all to build.")
451 set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
452 endif(NOT RESULT STREQUAL "-1")
454 endmacro(ALICE_BuildLibrary)
456 macro(ALICE_BuildExecutable)
458 ALICE_DevFlagsOutput()
459 set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS} ${EXEFLAGS}")
460 set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS} ${EXEFLAGS}")
461 set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS} ${EXEFLAGS}")
462 set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
463 set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
465 separate_arguments(PINC)
466 separate_arguments(EINCLUDE)
467 separate_arguments(PELIBSDIR)
468 separate_arguments(PBLIBS)
469 separate_arguments(PELIBS)
470 separate_arguments(SHLIB)
472 ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
473 ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
474 #ALICE_CheckLibraries(PELIBS "${PELIBS}")
476 ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
477 ALICE_CorrectPaths(PINC "${PINC}")
479 include_directories(SYSTEM ${ROOTINCDIR})
480 include_directories(${PINC})
481 include_directories(${EINCLUDE})
482 include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
484 if(ALIPROFILE STREQUAL "YES")
485 add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
486 if(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
487 target_link_libraries(${PACKAGE} ${ARLIBS} ${SHLIBS} ${PBLIBS} ${EXEFLAGS})
488 endif(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
489 add_dependencies(${MODULE}-all ${PACKAGE})
491 add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
492 if(PELIBS OR PBLIBS OR EXEFLAGS)
493 target_link_libraries(${PACKAGE} ${BINLIBDIRS} ${PELIBSDIR} ${PELIBS} ${PBLIBS} ${EXEFLAGS})
494 endif(PELIBS OR PBLIBS OR EXEFLAGS)
495 add_dependencies(${MODULE}-all ${PACKAGE})
496 endif(ALIPROFILE STREQUAL "YES")
498 list(FIND EXCLUDEMODULES ${MODULE} RESULT)
499 if(NOT RESULT STREQUAL "-1")
500 set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
501 endif(NOT RESULT STREQUAL "-1")
503 endmacro(ALICE_BuildExecutable)
505 macro(ALICE_CopyHeaders)
510 set(HEADERS ${EXPORT})
512 foreach(header ${HEADERS})
513 configure_file(${header} ${PEXPORTDEST} COPYONLY)
514 install(FILES ${header} DESTINATION include)
517 endmacro(ALICE_CopyHeaders)
519 macro(ALICE_GenerateLinkDef)
521 file (WRITE ${PDAL} "//--------------------------------------------------------------------------------\n")
522 file (APPEND ${PDAL} "// This is an automatically generated Root Dictionary Linkdef file for ${PACKAGE}\n")
523 file (APPEND ${PDAL} "// !!! DO NOT EDIT THIS FILE !!!\n")
524 file (APPEND ${PDAL} "#ifdef __CINT__\n")
525 file (APPEND ${PDAL} "#pragma link off all globals;\n")
526 file (APPEND ${PDAL} "#pragma link off all classes;\n")
527 file (APPEND ${PDAL} "#pragma link off all functions;\n")
528 foreach (class ${PCINTCLASSES})
529 get_filename_component(classname ${class} NAME)
530 file(APPEND ${PDAL} "#pragma link C++ class ${classname}+;\n")
532 file (APPEND ${PDAL} "#endif\n")
533 endmacro(ALICE_GenerateLinkDef)