3 # AliRoot Build System Utility Macro and Function definitions
5 # Author: Johny Jose (johny.jose@cern.ch)
6 # Port of previous Makefile build to cmake
8 cmake_minimum_required(VERSION 2.8.8 FATAL_ERROR)
10 macro(ALICE_DevFlagsOutput)
12 if(ALICEDEV STREQUAL "YES")
13 message(STATUS "FFLAGS : ${FFLAGS}")
14 message(STATUS "CXXFLAGS : ${CXXFLAGS}")
15 message(STATUS "CFLAGS : ${CFLAGS}")
16 message(STATUS "SOFLAGS : ${SOFLAGS}")
17 message(STATUS "LDFLAGS : ${LDFLAGS}")
18 message(STATUS "SHLIB : ${SHLIB}")
19 message(STATUS "SYSLIBS : ${SYSLIBS}")
20 message(STATUS "CINTFLAGS : ${CINTFLAGS}")
21 message(STATUS "CMAKE_Fortran_FLAGS : ${CMAKE_Fortran_FLAGS}")
22 message(STATUS "CMAKE_CXX_FLAGS : ${CMAKE_CXX_FLAGS}")
23 message(STATUS "CMAKE_C_FLAGS : ${CMAKE_C_FLAGS}")
24 message(STATUS "CMAKE_SHARED_LINKER_FLAGS : ${CMAKE_SHARED_LINKER_FLAGS}")
25 message(STATUS "CMAKE_MODULE_LINKER_FLAGS : ${CMAKE_MODULE_LINKER_FLAGS}")
26 message(STATUS "CMAKE_EXE_LINKER_FLAGS : ${CMAKE_EXE_LINKER_FLAGS}")
27 endif(ALICEDEV STREQUAL "YES")
29 endmacro(ALICE_DevFlagsOutput)
31 function(ALICE_CleanOutput _output input)
33 string(REGEX REPLACE "\n" " " clean "${input}")
34 set(${_output} ${clean} PARENT_SCOPE)
36 endfunction(ALICE_CleanOutput)
38 function(ALICE_CorrectPaths _output value )
41 foreach(path ${value})
43 string(REGEX MATCH "^/" external "${path}")
45 list(APPEND corrected "${AliRoot_SOURCE_DIR}/${path}" )
47 list(APPEND corrected "${path}")
50 set(${_output} ${corrected} PARENT_SCOPE)
52 endfunction(ALICE_CorrectPaths)
54 function(ALICE_Format _output prefix suffix input)
56 # DevNotes - input should be put in quotes or the complete list does not get passed to the function
61 string(REGEX MATCH "^${prefix}" pre "${arg}")
64 string(REGEX MATCH "${suffix}$" suf "${arg}")
67 set(item "${prefix}${item}")
70 set(item "${item}${suffix}")
72 list(APPEND format ${item})
74 set(${_output} ${format} PARENT_SCOPE)
76 endfunction(ALICE_Format)
78 function(ALICE_CheckLibraries _output input)
83 string(REGEX MATCH "^(/|-)" preformatted "${item}")
86 endif(NOT preformatted)
87 list(APPEND format ${item})
89 set(${_output} ${format} PARENT_SCOPE)
91 endfunction(ALICE_CheckLibraries)
93 function(ALICE_RootConfig _output parameters)
96 execute_process(COMMAND ${ROOT_CONFIG} ${parameters} OUTPUT_VARIABLE result ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE )
98 message(FATAL_ERROR "root-config ERROR : ${error}")
100 ALICE_CleanOutput(result "${result}")
101 set(${_output} "${result}" PARENT_SCOPE)
103 message(FATAL_ERROR "root-config not found")
106 endfunction(ALICE_RootConfig)
108 macro(ALICE_CheckOutOfSourceBuild)
110 #Check if previous in-source build failed
111 if(EXISTS ${AliRoot_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${AliRoot_SOURCE_DIR}/CMakeFiles)
112 message(FATAL_ERROR "CMakeCache.txt or CMakeFiles exists in source directory! Please remove them before running cmake $ALICE_ROOT")
113 endif(EXISTS ${AliRoot_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${AliRoot_SOURCE_DIR}/CMakeFiles)
115 #Get Real Paths of the source and binary directories
116 get_filename_component(srcdir "${AliRoot_SOURCE_DIR}" REALPATH)
117 get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
119 #Check for in-source builds
120 if(${srcdir} STREQUAL ${bindir})
121 message(FATAL_ERROR "AliRoot cannot be built in-source! Please run cmake $ALICE_ROOT outside the source directory")
122 endif(${srcdir} STREQUAL ${bindir})
124 endmacro(ALICE_CheckOutOfSourceBuild)
126 macro(ALICE_ConfigureCompiler)
128 if(ALIPROFILE STREQUAL "YES")
129 set(ALICE_TARGET ${ALICE_TARGET}PROF)
130 set(FFLAGS "-pg ${FFLAGS}")
131 set(CXXFLAGS "-pg ${CXXFLAGS}")
132 set(CFLAGS "-pg ${CFLAGS}")
133 set(SOFLAGS "-pg ${SOFLAGS}")
134 set(LDFLAGS "-pg ${LDFLAGS}")
135 endif(ALIPROFILE STREQUAL "YES")
137 ALICE_RootConfig(RCFLAGS --auxcflags)
138 if ( CMAKE_CXX_COMPILER MATCHES "clang")
139 string(REPLACE "-pthread" " " RCFLAGS "${RCFLAGS}")
140 endif ( CMAKE_CXX_COMPILER MATCHES "clang")
142 ALICE_RootConfig(RLFLAGS --ldflags)
144 set(CXXFLAGS "${CXXFLAGS} ${RCFLAGS}")
145 string(REPLACE "-std=c++11" " " RCFLAGS "${RCFLAGS}")
146 set(CFLAGS "${CFLAGS} ${RCFLAGS}")
147 set(SOFLAGS "${SOFLAGS} ${RLFLAGS}")
148 set(LDFLAGS "${LDFLAGS} ${RLFLAGS}")
150 if(NOT ALICXXWARN STREQUAL "NO")
151 set(CXXFLAGS "${CXXFLAGS} ${CXXWARN}")
152 endif(NOT ALICXXWARN STREQUAL "NO")
154 set(CXXFLAGS "${DATEFLAGS} ${CXXFLAGS}")
155 set(CFLAGS "${DATEFLAGS} ${CFLAGS}")
156 set(CINTFLAGS "${DATEFLAGS}")
158 endmacro(ALICE_ConfigureCompiler)
160 macro(ALICE_ConfigurePlatform)
163 include("CMake${ALICE_TARGET}")
165 endmacro(ALICE_ConfigurePlatform)
167 macro(ALICE_GetTarget)
169 #Set ALICE_TARGET if it has not been set yet
171 set(ALICE_TARGET $ENV{ALICE_TARGET})
172 #If ALICE_TARGET is not defined assign default values
174 message(WARNING "Environment variable ALICE_TARGET is not set ! Setting to default value.")
175 ALICE_RootConfig(ALICE_TARGET --arch)
176 message("ALICE_TARGET set to ${ALICE_TARGET}")
177 endif(NOT ALICE_TARGET)
178 endif(NOT ALICE_TARGET)
180 endmacro(ALICE_GetTarget)
182 macro(ALICE_ResetPackage)
184 set(MODDIR ${MODULE})
185 set(MODDIRI ${PROJECT_SOURCE_DIR}/${MODULE})
248 endmacro(ALICE_ResetPackage)
250 function(ALICE_SetPackageVariable _var ext setvalue unsetvalue )
252 #DevNotes - setvalue and unsetcalue should both be put in quotes or cmake throws an error if they have undefined values
254 set(${_var} ${setvalue} PARENT_SCOPE)
255 set(${PACKAGE}${ext} ${setvalue} PARENT_SCOPE)
257 set(${_var} ${unsetvalue} PARENT_SCOPE)
258 set(${PACKAGE}${ext} ${unsetvalue} PARENT_SCOPE)
261 endfunction(ALICE_SetPackageVariable)
263 macro(ALICE_BuildPackage)
264 # message(STATUS " ${PACKAGE}")
266 list(APPEND EINCLUDE STEER)
267 # Needed for PAR files - we need to do this before path
268 # expansion so that the PAR files do not contain references to
269 # specific directories but depend solely on ALICE_ROOT
270 string(REPLACE ";" " " saveEINCLUDE "${EINCLUDE}")
271 # set(saveEINCLUDE "${EINCLUDE}")
272 # message(STATUS "saveEINCLUDE=${saveEINCLUDE} EINCLUDE=${EINCLUDE}")
274 ALICE_SetPackageVariable(PFFLAGS "FFLAGS" "${PACKFFLAGS}" "${FFLAGS}")
275 ALICE_SetPackageVariable(PCFLAGS "CFLAGS" "${PACKCFLAGS}" "${CFLAGS}")
276 ALICE_SetPackageVariable(PCXXFLAGS "CXXFLAGS" "${PACKCXXFLAGS}" "${CXXFLAGS}")
277 ALICE_SetPackageVariable(PSOFLAGS "SOFLAGS" "${PACKSOFLAGS}" "${SOFLAGS}")
278 ALICE_SetPackageVariable(PLDFLAGS "LDFLAGS" "${PACKLDFLAGS}" "${LDFLAGS}")
279 ALICE_SetPackageVariable(PDCXXFLAGS "DCXXFLAGS" "${PACKDCXXFLAGS}" "${CXXFLAGSNO}")
280 ALICE_SetPackageVariable(PBLIBS "BLIBS" "${PACKBLIBS}" "${LIBS}")
283 if(DHDR OR CINTAUTOLINK)
285 endif(DHDR OR CINTAUTOLINK)
287 ALICE_SetPackageVariable(PEDEFINE "EDEFINE" "${EDEFINE}" "${EDEFINE}")
288 ALICE_SetPackageVariable(PEXPORT "EXPORT" "${EXPORT}" "${EXPORT}")
289 # message(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
290 ALICE_SetPackageVariable(PEXPORTDEST "EXPORTDEST" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
291 ALICE_SetPackageVariable(PINC "INC" "${EINCLUDE};${MODULE}" "${EINCLUDE};${MODULE}")
292 ALICE_SetPackageVariable(PELIBS "ELIBS" "${ELIBS}" "${ELIBS}")
293 ALICE_SetPackageVariable(PELIBSDIR "ELIBSDIR" "${ELIBSDIR}" "${ELIBSDIR}")
295 ALICE_SetPackageVariable(PCS "CS" "${CSRCS}" "${CSRCS}")
296 ALICE_SetPackageVariable(PCH "CH" "${CHDRS}" "${CHDRS}")
298 ALICE_SetPackageVariable(PFS "FS" "${FSRCS}" "${FSRCS}")
300 ALICE_SetPackageVariable(PS "S" "${SRCS}" "${SRCS}")
301 ALICE_SetPackageVariable(PH "H" "${HDRS} ${EHDRS}" "${HDRS} ${EHDRS}")
302 ALICE_SetPackageVariable(PCINTHDRS "CINTHDRS" "${CINTHDRS}" "${PH}")
304 string( REPLACE ".h" "" PCINTCLASSES "${PCINTHDRS}")
305 set ( ${PACKAGE}CINTCLASSES ${PCINTCLASSES})
307 ALICE_SetPackageVariable(PDH "DH" "${DHDR}" "")
310 ALICE_SetPackageVariable(PDAL "DAL" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h")
311 ALICE_SetPackageVariable(PDH "DH" "${PDAL}" "${PDAL}")
312 ALICE_GenerateLinkDef()
316 list(APPEND PMLIBS ${PACKAGE})
317 list(APPEND ALLLIBS ${PACKAGE})
318 list(APPEND PMALIBS ${PACKAGE}-static)
319 list(APPEND ALLALIBS ${PACKAGE}-static)
320 list(APPEND BINLIBS ${PACKAGE})
321 # Do not link against other libraries when creating a library
324 list(APPEND ALLEXECS ${PACKAGE})
326 set(${MODULE}ALIBS "${PMALIBS}" PARENT_SCOPE)
327 set(${MODULE}LIBS "${PMLIBS}" PARENT_SCOPE)
328 set(${MODULE}INC "${EINCLUDE}" PARENT_SCOPE)
329 list(APPEND INCLUDEFILES ${PEXPORTDEST})
331 # Replace dots in file name with underscores, or rootcint will
332 # write invalid code (namespace names with dots in them)
333 string(REPLACE "." "_" ESC_PACKAGE ${PACKAGE})
334 ALICE_SetPackageVariable(PDS "DS" "G__${ESC_PACKAGE}.cxx" "G__${ESC_PACKAGE}.cxx")
335 ALICE_GenerateDictionary()
338 message(STATUS "No dictionary generated for ${PACKAGE}")
345 ALICE_BuildExecutable()
347 endif(PS OR PCS OR PFS)
351 endmacro(ALICE_BuildPackage)
354 macro(ALICE_BuildModule)
355 # message(STATUS "${MODULE}")
356 execute_process(COMMAND ${CMAKE_COMMAND} -E echo_append "-- ${MODULE}:")
357 add_definitions(-D_MODULE_="${MODULE}")
358 foreach(PACKAGEFILE ${PACKAGES})
361 string(REGEX MATCH "CMakelib" lib "${PACKAGEFILE}")
362 string(REGEX MATCH "CMakebin" bin "${PACKAGEFILE}")
363 get_filename_component(PACKAGE ${PACKAGEFILE} NAME)
364 string(REGEX REPLACE "^CMake(lib|bin)(.*)\\.pkg" "\\2" PACKAGE "${PACKAGE}")
365 execute_process(COMMAND ${CMAKE_COMMAND} -E echo_append " ${PACKAGE}")
367 message("Adding package ${PACKAGE} in ${MODULE}")
370 include(${PACKAGEFILE})
373 get_property(EXCLUDEPACKAGE TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL)
374 if(NOT EXCLUDEPACKAGE)
375 install(TARGETS ${PACKAGE}
376 RUNTIME DESTINATION bin/tgt_${ALICE_TARGET}
377 LIBRARY DESTINATION lib/tgt_${ALICE_TARGET}
378 ARCHIVE DESTINATION bin/tgt_${ALICE_TARGET})
379 endif(NOT EXCLUDEPACKAGE)
380 endforeach(PACKAGEFILE)
382 execute_process(COMMAND ${CMAKE_COMMAND} -E echo " done")
383 endmacro(ALICE_BuildModule)
385 macro(ALICE_GenerateDictionary)
387 if(ALICEDEV STREQUAL "YES")
388 message("Generating Dictionary rule for ${PACKAGE}")
389 message("${ROOTCINT} -f ${PDS} -c ${PEDEFINE} ${CINTFLAGS} ${PINC} ${PCINTHDRS} ${PDH}")
390 endif(ALICEDEV STREQUAL "YES")
392 # Split up all arguments
394 set(DEDEFINE ${PEDEFINE})
395 set(DCINTFLAGS ${CINTFLAGS})
397 set(DCINTHDRS ${PCINTHDRS})
399 separate_arguments(DEDEFINE)
400 separate_arguments(DCINTFLAGS)
401 separate_arguments(DINC)
402 separate_arguments(DCINTHDRS)
403 separate_arguments(DDH)
404 # Format neccesary arguments
405 set(ROOT6_ALPHA "5.99.1")
406 string(REGEX REPLACE "/0*" "." ROOT_DOTVERSION ${ROOT_VERSION})
407 if(ROOT_DOTVERSION VERSION_GREATER ROOT6_ALPHA)
408 # For current ROOT6-alpha - without proper PCM support - we need to
409 # give the _full_ path for all include paths, so that libCling can
410 # later attach those to the internal include path of the interpreter
411 # and so that the interpreter can parse the header files.
413 # THIS SHOULD BE A TEMPORARY HACK!
414 ALICE_Format(DINC "-I${PROJECT_SOURCE_DIR}/" ""
415 "${DINC};${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
417 ALICE_Format(DINC "-I" "" "${DINC};${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
418 endif(ROOT_DOTVERSION VERSION_GREATER ROOT6_ALPHA)
419 set_source_files_properties(${PDS} PROPERTIES GENERATED TRUE)
420 set_source_files_properties(${PDS} PROPERTIES COMPILE_FLAGS "-w")
421 add_custom_command(OUTPUT ${PDS}
422 COMMAND cd ${PROJECT_SOURCE_DIR} && ${ROOTCINT} -f ${CMAKE_CURRENT_BINARY_DIR}/${PDS} -c -D_MODULE=\\\"${MODULE}\\\" ${DEDEFINE} ${DCINTFLAGS} ${DINC} ${DCINTHDRS} ${DDH}
423 WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
424 DEPENDS ${DCINTHDRS} ${DDH}
426 add_custom_target(G${PACKAGE})
427 add_dependencies(G${PACKAGE} ${PDS})
429 endmacro(ALICE_GenerateDictionary)
431 macro(ALICE_BuildLibrary)
433 set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS}")
434 set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS}")
435 set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS}")
436 set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
437 set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
438 ALICE_DevFlagsOutput()
441 separate_arguments(PINC)
442 separate_arguments(EINCLUDE)
443 separate_arguments(PELIBSDIR)
444 separate_arguments(PBLIBS)
445 separate_arguments(PELIBS)
446 separate_arguments(SHLIB)
448 ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
449 ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
451 ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
452 ALICE_CorrectPaths(PINC "${PINC}")
454 include_directories(SYSTEM ${ROOTINCDIR})
455 include_directories(${PINC})
456 include_directories(${EINCLUDE})
457 include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY}/FromTemplate)
458 include_directories(${AliRoot_SOURCE_DIR})
460 add_library(${PACKAGE} SHARED ${PCS} ${PFS} ${PS} ${PDS})
461 set_target_properties(${PACKAGE} PROPERTIES SUFFIX .so)
465 target_link_libraries(${PACKAGE} ${PELIBSDIR} ${PELIBS} ${SHLIB})
466 endif(PELIBS OR SHLIB)
468 add_dependencies(${MODULE}-all ${PACKAGE})
470 add_library(${PACKAGE}-static STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS})
471 set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME ${PACKAGE})
473 target_link_libraries(${PACKAGE}-static ${PELIBSDIR} ${PELIBS} ${ALLIB})
474 endif(PELIBS OR ALLIB)
476 add_dependencies(${MODULE}-all-static ${PACKAGE}-static)
477 if(ALIPROFILE STREQUAL "YES")
478 add_dependencies(${MODULE}-all ${MODULE}-static)
479 endif(ALIPROFILE STREQUAL "YES")
481 list(FIND EXCLUDEMODULES ${MODULE} RESULT)
482 if(NOT RESULT STREQUAL "-1")
483 message(STATUS "${MODULE} will not be built by default. Type make ${MODULE}-all to build.")
484 set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
485 endif(NOT RESULT STREQUAL "-1")
487 set_target_properties(${PACKAGE} PROPERTIES INSTALL_NAME_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
489 endmacro(ALICE_BuildLibrary)
491 macro(ALICE_BuildExecutable)
493 set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS} ${EXEFLAGS}")
494 set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS} ${EXEFLAGS}")
495 set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS} ${EXEFLAGS}")
496 set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
497 set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
498 set(CMAKE_EXE_LINKER_FLAGS ${PLDFLAGS})
499 ALICE_DevFlagsOutput()
501 separate_arguments(PINC)
502 separate_arguments(EINCLUDE)
503 separate_arguments(PELIBSDIR)
504 separate_arguments(PBLIBS)
505 separate_arguments(PELIBS)
506 separate_arguments(SHLIB)
508 ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
509 ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
511 ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
512 ALICE_CorrectPaths(PINC "${PINC}")
514 include_directories(SYSTEM ${ROOTINCDIR})
515 include_directories(${PINC})
516 include_directories(${EINCLUDE})
517 include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
519 if(ALIPROFILE STREQUAL "YES")
520 add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
521 if(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
522 target_link_libraries(${PACKAGE} ${ARLIBS} ${SHLIBS} ${PBLIBS} ${EXEFLAGS})
523 endif(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
524 add_dependencies(${MODULE}-all ${PACKAGE})
526 add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
527 if(PELIBS OR PBLIBS OR EXEFLAGS)
528 target_link_libraries(${PACKAGE} ${BINLIBDIRS} ${PELIBSDIR} ${PELIBS} ${PBLIBS} ${EXEFLAGS})
529 endif(PELIBS OR PBLIBS OR EXEFLAGS)
530 add_dependencies(${MODULE}-all ${PACKAGE})
531 endif(ALIPROFILE STREQUAL "YES")
534 # ------------------------------
535 if(PACKAGE STREQUAL "alimdc" AND GENERATEPACKAGES)
537 add_executable(${PACKAGE}-static ${PFS} ${PCS} ${PS} ${PDS})
538 set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME alimdca)
539 add_custom_target( libAliMDC
540 COMMAND rm -rf ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a
541 COMMAND rm -rf junkmdc
542 COMMAND mkdir junkmdc && cd junkmdc && ar x ../libRAWDatabase.a && ar x ../libMDC.a && ar x ../libESD.a && ar x ../libSTEERBase.a && ar r ../libAliMDC.a *.o && cd .. && rm -rf junkmdc
543 WORKING_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
544 add_custom_target( root-static-libs
546 WORKING_DIRECTORY ${ROOTSYS} )
548 add_dependencies(libAliMDC RAWDatabase-static STEERBase-static MDC-static ESD-static)
549 add_dependencies(${PACKAGE}-static libAliMDC root-static-libs)
550 target_link_libraries(${PACKAGE}-static ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a ${ROOTLIBDIR}/libRoot.a ${ROOTLIBDIR}/libfreetype.a ${ROOTLIBDIR}/libpcre.a -pthread -ldl -lcurses)
552 install(TARGETS ${PACKAGE}-static RUNTIME DESTINATION bin/tgt_${ALICE_TARGET} COMPONENT MDC)
553 install(FILES ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a ${ROOTLIBDIR}/libRoot.a ${ROOTLIBDIR}/libfreetype.a ${ROOTLIBDIR}/libpcre.a DESTINATION lib/tgt_${ALICE_TARGET} COMPONENT MDC)
554 install(FILES ${PROJECT_SOURCE_DIR}/RAW/mdc.h DESTINATION include COMPONENT MDC)
555 set(CPACK_RPM_PACKAGE_SUMMARY "AliMDC static libraries")
556 set(CPACK_RPM_PACKAGE_NAME "alimdc")
557 set(CPACK_RPM_PACKAGE_VERSION "${ALIMDCVERSION}")
558 set(CPACK_RPM_PACKAGE_RELEASE "${ALIMDCRELEASE}")
559 set(CPACK_RPM_PACKAGE_LICENSE "License: CERN ALICE Off-line Group")
560 set(CPACK_RPM_PACKAGE_VENDOR "ALICE Core Off-line Group")
561 set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "AliMDC static libraries")
562 set(CPACK_RPM_PACKAGE_GROUP "Applications/Alice")
563 set(CPACK_RPM_PACKAGE_REQUIRES "glibc")
564 set(CPACK_PACKAGE_VERSION "1.0.0")
565 set(CPACK_PACKAGE_VERSION_MAJOR "1")
566 set(CPACK_PACKAGE_VERSION_MINOR "0")
567 set(CPACK_PACKAGE_VERSION_PATCH "0")
568 set(CPACK_PACKAGE_INSTALL_DIRECTORY "/opt/")
569 add_component_package(MDC alimdc-rpm)
571 endif(PACKAGE STREQUAL "alimdc" AND GENERATEPACKAGES)
573 list(FIND EXCLUDEMODULES ${MODULE} RESULT)
574 if(NOT RESULT STREQUAL "-1")
575 set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
576 endif(NOT RESULT STREQUAL "-1")
578 endmacro(ALICE_BuildExecutable)
580 macro(ALICE_CopyHeaders)
583 set(HEADERS ${EXPORT})
585 foreach(header ${HEADERS})
586 get_filename_component( header_name ${header} NAME )
587 add_custom_command(OUTPUT ${PEXPORTDEST}/${header_name}
588 COMMAND ${CMAKE_COMMAND} -E copy ${AliRoot_SOURCE_DIR}/${MODULE}/${header} ${PEXPORTDEST}/${header_name}
589 DEPENDS ${AliRoot_SOURCE_DIR}/${MODULE}/${header})
590 list(APPEND _headersdep ${PEXPORTDEST}/${header_name})
591 install(FILES ${header} DESTINATION include)
593 add_custom_target(${PACKAGE}-headers DEPENDS ${_headersdep})
594 add_dependencies(${PACKAGE} ${PACKAGE}-headers)
597 endmacro(ALICE_CopyHeaders)
599 macro(ALICE_GenerateLinkDef)
601 foreach (class ${PCINTCLASSES})
602 get_filename_component(classname ${class} NAME)
603 # set(PCLASSES ${PCLASSES} "\\n#pragma link C++ class ${classname}+;")
604 set(PCLASSES ${PCLASSES} "${classname}")
607 add_custom_command(OUTPUT ${PDAL}
608 COMMAND sh ${AliRoot_SOURCE_DIR}/cmake/GenerateLinkDef.sh ${PCLASSES} > ${PDAL}
609 DEPENDS ${PCINTHDRS} ${AliRoot_SOURCE_DIR}/cmake/GenerateLinkDef.sh)
610 endmacro(ALICE_GenerateLinkDef)
612 macro(ALICE_BuildPAR)
614 if(EXISTS ${AliRoot_SOURCE_DIR}/${MODULE}/PROOF-INF.${PACKAGE})
616 foreach(file ${SRCS} ${HDRS} ${FSRCS} ${DHDR} ${OTHERS} )
617 get_filename_component(srcdir ${file} PATH)
618 add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}-par
619 COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${srcdir}
620 COMMAND cp -pR ${file} ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}
621 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
622 list(APPEND PARSRCS ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}-par)
623 endforeach(file ${SRCS} ${HDRS} ${FSRCS} ${DHDR} ${OTHERS} )
625 # message(STATUS "saveEINCLUDE=${saveEINCLUDE}")
626 add_custom_target(${PACKAGE}.par
627 COMMAND sed -e 's,include ..ROOTSYS./\\\(etc\\|test\\\)/Makefile.arch,include Makefile.arch,\; s/PACKAGE = .*/PACKAGE = ${PACKAGE}/\; s,SRCS *=.*,SRCS = ${SRCS},\;' < Makefile | sed -e 's,HDRS *=.*,HDRS = ${HDRS},\; s,FSRCS *=.*,FSRCS = ${FSRCS},\; s,DHDR *=.*,DHDR = ${DHDR},\; s,EINCLUDE *:=.*,EINCLUDE := ${saveEINCLUDE},' > ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/Makefile
628 COMMAND cp -pR `root-config --etcdir`/Makefile.arch ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/Makefile.arch
629 COMMAND cp -pR PROOF-INF.${PACKAGE} ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/PROOF-INF
630 # COMMAND cp -pR lib${PACKAGE}.pkg ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}
631 COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_CURRENT_BINARY_DIR} tar --exclude=.svn -czhf ${CMAKE_BINARY_DIR}/${PACKAGE}.par ${PACKAGE}
632 COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}
633 COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --red --bold "${PACKAGE}.par has been created in ${CMAKE_BINARY_DIR}"
635 WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
638 add_dependencies(${PACKAGE}.par ${SRCS} ${FSRCS} ${HDRS} ${DHDR})
639 add_dependencies(par-all ${PACKAGE}.par)
640 add_dependencies(${MODULE}-par-all ${PACKAGE}.par)
642 add_custom_target(test-${PACKAGE}.par
643 COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --red --bold "The file ${PACKAGE}.par is now being tested, in case of an error check in par-tmp/${PACKAGE}."
644 COMMAND ${CMAKE_COMMAND} -E make_directory par-tmp
645 COMMAND ${CMAKE_COMMAND} -E chdir par-tmp tar xfz ../${PACKAGE}.par && ${CMAKE_COMMAND} -E chdir par-tmp/${PACKAGE} PROOF-INF/BUILD.sh
646 COMMAND ${CMAKE_COMMAND} -E remove_directory par-tmp
647 COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green --bold "${PACKAGE}.par testing succeeded"
648 WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
650 add_dependencies(test-${PACKAGE}.par ${PACKAGE}.par)
651 add_dependencies(test-par-all test-${PACKAGE}.par)
652 add_dependencies(test-${MODULE}-par-all test-${PACKAGE}.par)
654 endif(EXISTS ${AliRoot_SOURCE_DIR}/${MODULE}/PROOF-INF.${PACKAGE})
655 # endif(EXISTS ${ALICE_ROOT}/${MODULE}/PROOF-INF.${PACKAGE})
657 endmacro(ALICE_BuildPAR)