cmake/ALICE_CMake.cmake

   1 # -*- mode: cmake -*-
   2
   3 # AliRoot Build System Utility Macro and Function definitions
   4 #
   5 # Author: Johny Jose (johny.jose@cern.ch)
   6 #         Port of previous Makefile build to cmake
   7
   8 cmake_minimum_required(VERSION 2.8.4 FATAL_ERROR)
   9
  10 macro(ALICE_DevFlagsOutput)
  11
  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   endif(ALICEDEV STREQUAL "YES")
  22
  23 endmacro(ALICE_DevFlagsOutput)
  24
  25 function(ALICE_CleanOutput _output input)
  26
  27   string(REGEX REPLACE "\n" " " clean "${input}")
  28   set(${_output} ${clean} PARENT_SCOPE)
  29
  30 endfunction(ALICE_CleanOutput)
  31
  32 function(ALICE_CorrectPaths _output value )
  33
  34   set(corrected)
  35   foreach(path ${value})
  36     set(external)
  37     string(REGEX MATCH "^/" external "${path}")
  38     if(NOT external)
  39       list(APPEND corrected "${CMAKE_SOURCE_DIR}/${path}" )
  40     else()
  41       list(APPEND corrected "${path}")
  42     endif(NOT external)
  43   endforeach(path)
  44   set(${_output} ${corrected} PARENT_SCOPE)
  45
  46 endfunction(ALICE_CorrectPaths)
  47
  48 function(ALICE_Format _output prefix suffix input)
  49
  50 # DevNotes - input should be put in quotes or the complete list does not get passed to the function
  51   set(format)
  52   foreach(arg ${input})
  53     set(item ${arg})
  54     if(prefix)
  55       string(REGEX MATCH "^${prefix}" pre "${arg}")
  56     endif(prefix)
  57     if(suffix)
  58       string(REGEX MATCH "${suffix}$" suf "${arg}")
  59     endif(suffix)
  60     if(NOT pre)
  61       set(item "${prefix}${item}")
  62     endif(NOT pre)
  63     if(NOT suf)
  64       set(item "${item}${suffix}")
  65     endif(NOT suf)
  66     list(APPEND format ${item})
  67   endforeach(arg)
  68   set(${_output} ${format} PARENT_SCOPE)
  69
  70 endfunction(ALICE_Format)
  71
  72 function(ALICE_CheckLibraries _output input)
  73
  74   set(format)
  75   foreach(arg ${input})
  76     set(item ${arg})
  77     string(REGEX MATCH "^(/|-)" preformatted "${item}")
  78     if(NOT preformatted)
  79       set(item "-l${item}")
  80     endif(NOT preformatted)
  81     list(APPEND format ${item})
  82   endforeach(arg)
  83   set(${_output} ${format} PARENT_SCOPE)
  84
  85 endfunction(ALICE_CheckLibraries)
  86
  87 function(ALICE_RootConfig _output parameters)
  88
  89   if(ROOT_CONFIG)
  90     execute_process(COMMAND ${ROOT_CONFIG} ${parameters} OUTPUT_VARIABLE result ERROR_VARIABLE error OUTPUT_STRIP_TRAILING_WHITESPACE )
  91     if(error)
  92       message(FATAL_ERROR "root-config ERROR : ${error}")
  93     endif(error)
  94     ALICE_CleanOutput(result "${result}")
  95     set(${_output} "${result}" PARENT_SCOPE)
  96   else()
  97     message(FATAL_ERROR "root-config not found")
  98   endif(ROOT_CONFIG)
  99
 100 endfunction(ALICE_RootConfig)
 101
 102 macro(ALICE_CheckOutOfSourceBuild)
 103
 104   #Check if previous in-source build failed
 105   if(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${CMAKE_SOURCE_DIR}/CMakeFiles)
 106     message(FATAL_ERROR "CMakeCache.txt or CMakeFiles exists in source directory! Please remove them before running cmake $ALICE_ROOT")
 107   endif(EXISTS ${CMAKE_SOURCE_DIR}/CMakeCache.txt OR EXISTS ${CMAKE_SOURCE_DIR}/CMakeFiles)
 108
 109   #Get Real Paths of the source and binary directories
 110   get_filename_component(srcdir "${CMAKE_SOURCE_DIR}" REALPATH)
 111   get_filename_component(bindir "${CMAKE_BINARY_DIR}" REALPATH)
 112
 113   #Check for in-source builds
 114   if(${srcdir} STREQUAL ${bindir})
 115     message(FATAL_ERROR "AliRoot cannot be built in-source! Please run cmake $ALICE_ROOT outside the source directory")
 116   endif(${srcdir} STREQUAL ${bindir})
 117
 118 endmacro(ALICE_CheckOutOfSourceBuild)
 119
 120 macro(ALICE_ConfigureCompiler)
 121
 122   if(ALIDEBUG STREQUAL "YES")
 123     set(ALICE_TARGET ${ALICE_TARGET}DEBUG)
 124     message("Befor ${CXXFLAGS}")
 125     string(REGEX MATCHALL "-O[^ ]*" FFLAGS "${FFLAGS}")
 126     string(REGEX MATCHALL "-O[^ ]*" CXXFLAGS "${CXXFLAGS}")
 127     message("After ${CXXFLAGS}")
 128     string(REGEX MATCHALL "-O[^ ]*" CFLAGS "${CFLAGS}")
 129     string(REGEX MATCHALL "-O[^ ]*" SOFLAGS "${SOFLAGS}")
 130     string(REGEX MATCHALL "-O[^ ]*" LDFLAGS "${LDFLAGS}")
 131     set(FFLAGS "-g ${FFLAGS}")
 132     set(CXXFLAGS "-g ${CXXFLAGS}")
 133     set(CFLAGS "-g ${CFLAGS}")
 134     set(SOFLAGS "-g ${SOFLAGS}")
 135     set(LDFLAGS "-g ${LDFLAGS}")
 136   endif(ALIDEBUG STREQUAL "YES")
 137
 138   if(ALIPROFILE STREQUAL "YES")
 139     set(ALICE_TARGET ${ALICE_TARGET}PROF)
 140     set(FFLAGS "-pg ${FFLAGS}")
 141     set(CXXFLAGS "-pg ${CXXFLAGS}")
 142     set(CFLAGS "-pg ${CFLAGS}")
 143     set(SOFLAGS "-pg ${SOFLAGS}")
 144     set(LDFLAGS "-pg ${LDFLAGS}")
 145   endif(ALIPROFILE STREQUAL "YES")
 146
 147   ALICE_RootConfig(RCFLAGS --auxcflags)
 148   ALICE_RootConfig(RLFLAGS --ldflags)
 149
 150   set(CXXFLAGS "${CXXFLAGS} ${RCFLAGS}")
 151   set(CFLAGS  "${CFLAGS} ${RCFLAGS}")
 152   set(SOFLAGS "${SOFLAGS} ${RLFLAGS}")
 153   set(LDFLAGS "${LDFLAGS} ${RLFLAGS}")
 154
 155   if(NOT ALICXXWARN STREQUAL "NO")
 156     set(CXXFLAGS "${CXXFLAGS} ${CXXWARN}")
 157   endif(NOT ALICXXWARN STREQUAL "NO")
 158
 159   set(CXXFLAGS "${DATEFLAGS} ${CXXFLAGS}")
 160   set(CFLAGS "${DATEFLAGS} ${CFLAGS}")
 161   set(CINTFLAGS "${DATEFLAGS}")
 162
 163 endmacro(ALICE_ConfigureCompiler)
 164
 165 macro(ALICE_ConfigurePlatform)
 166
 167   ALICE_GetTarget()
 168   include("CMake${ALICE_TARGET}")
 169
 170 endmacro(ALICE_ConfigurePlatform)
 171
 172 macro(ALICE_GetTarget)
 173
 174   #Set ALICE_TARGET if it has not been set yet
 175   if(NOT ALICE_TARGET)
 176     set(ALICE_TARGET $ENV{ALICE_TARGET})
 177     #If ALICE_TARGET is not defined assign default values
 178     if(NOT ALICE_TARGET)
 179       message(WARNING "Environment variable ALICE_TARGET is not set ! Setting to default value.")
 180       ALICE_RootConfig(ALICE_TARGET --arch)
 181       message("ALICE_TARGET set to ${ALICE_TARGET}")
 182     endif(NOT ALICE_TARGET)
 183   endif(NOT ALICE_TARGET)
 184
 185 endmacro(ALICE_GetTarget)
 186
 187 macro(ALICE_ResetPackage)
 188
 189   set(MODDIR ${MODULE})
 190   set(MODDIRI ${PROJECT_SOURCE_DIR}/${MODULE})
 191
 192   set(SRCS)
 193   set(HDRS)
 194   set(FSRCS)
 195   set(DHDR)
 196   set(CSRCS)
 197   set(CHDRS)
 198   set(EINCLUDE)
 199   set(EDEFINE)
 200   set(ELIBS)
 201   set(ELIBSDIR)
 202   set(PACKFFLAGS)
 203   set(PACKCXXFLAGS)
 204   set(PACKCFLAGS)
 205   set(PACKDYFLAGS)
 206   set(PACKSOFLAGS)
 207   set(PACKLDFLAGS)
 208   set(PACKBLIBS)
 209   set(EXPORT)
 210   set(EHDRS)
 211   set(CINTHDRS)
 212   set(CINTAUTOLINK)
 213   set(ARLIBS)
 214   set(SHLIBS)
 215
 216   #HLT Variables
 217   set(MODULE_HDRS)
 218   set(MODULE_SRCS)
 219   set(MODULE_DHDR)
 220   set(CLASS_HDRS)
 221   set(LIBRARY_DEP)
 222   set(HLTDEFS)
 223   set(HLTSOFLAGS)
 224
 225
 226   set(PSRCS)
 227   set(PHDRS)
 228   set(PFSRCS)
 229   set(PDHDR)
 230   set(PCSRCS)
 231   set(PCHDRS)
 232   set(PEINCLUDE)
 233   set(PEDEFINE)
 234   set(PELIBS)
 235   set(PELIBSDIR)
 236   set(PPACKFFLAGS)
 237   set(PPACKCXXFLAGS)
 238   set(PPACKCFLAGS)
 239   set(PPACKDYFLAGS)
 240   set(PPACKSOFLAGS)
 241   set(PPACKLDFLAGS)
 242   set(PPACKBLIBS)
 243   set(PEXPORT)
 244   set(PEHDRS)
 245   set(PCINTHDRS)
 246   set(PCINTAUTOLINK)
 247   set(PARLIBS)
 248   set(PSHLIBS)
 249   set(PDS)
 250
 251 endmacro(ALICE_ResetPackage)
 252
 253 function(ALICE_SetPackageVariable _var ext setvalue unsetvalue )
 254
 255 #DevNotes - setvalue and unsetcalue should both be put in quotes or cmake throws an error if they have undefined values
 256   if(setvalue)
 257     set(${_var} ${setvalue} PARENT_SCOPE)
 258     set(${PACKAGE}${ext} ${setvalue} PARENT_SCOPE)
 259   else()
 260     set(${_var} ${unsetvalue} PARENT_SCOPE)
 261     set(${PACKAGE}${ext} ${unsetvalue} PARENT_SCOPE)
 262   endif(setvalue)
 263
 264 endfunction(ALICE_SetPackageVariable)
 265
 266 macro(ALICE_BuildPackage)
 267
 268   list(APPEND EINCLUDE STEER)
 269
 270   ALICE_SetPackageVariable(PFFLAGS "FFLAGS" "${PACKFFLAGS}" "${FFLAGS}")
 271   ALICE_SetPackageVariable(PCFLAGS "CFLAGS" "${PACKCFLAGS}" "${CFLAGS}")
 272   ALICE_SetPackageVariable(PCXXFLAGS "CXXFLAGS" "${PACKCXXFLAGS}" "${CXXFLAGS}")
 273   ALICE_SetPackageVariable(PSOFLAGS "SOFLAGS" "${PACKSOFLAGS}" "${SOFLAGS}")
 274   ALICE_SetPackageVariable(PLDFLAGS "LDFLAGS" "${PACKLDFLAGS}" "${LDFLAGS}")
 275   ALICE_SetPackageVariable(PDCXXFLAGS "DCXXFLAGS" "${PACKDCXXFLAGS}" "${CXXFLAGSNO}")
 276   ALICE_SetPackageVariable(PBLIBS "BLIBS" "${PACKBLIBS}" "${LIBS}")
 277
 278   set(WITHDICT)
 279   if(DHDR OR CINTAUTOLINK)
 280     set(WITHDICT TRUE)
 281   endif(DHDR OR CINTAUTOLINK)
 282
 283   ALICE_SetPackageVariable(PEDEFINE "EDEFINE" "${EDEFINE}" "${EDEFINE}")
 284   ALICE_SetPackageVariable(PEXPORT "EXPORT" "${EXPORT}" "${EXPORT}")
 285   ALICE_SetPackageVariable(PEXPORTDEST "EXPORTDEST" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}" "${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
 286   ALICE_SetPackageVariable(PINC "INC" "${EINCLUDE};${MODULE}" "${EINCLUDE};${MODULE}")
 287   ALICE_SetPackageVariable(PELIBS "ELIBS" "${ELIBS}" "${ELIBS}")
 288   ALICE_SetPackageVariable(PELIBSDIR "ELIBSDIR" "${ELIBSDIR}" "${ELIBSDIR}")
 289
 290   ALICE_SetPackageVariable(PCS "CS" "${CSRCS}" "${CSRCS}")
 291   ALICE_SetPackageVariable(PCH "CH" "${CHDRS}" "${CHDRS}")
 292
 293   ALICE_SetPackageVariable(PFS "FS" "${FSRCS}" "${FSRCS}")
 294
 295   ALICE_SetPackageVariable(PS "S" "${SRCS}" "${SRCS}")
 296   ALICE_SetPackageVariable(PH "H" "${HDRS} ${EHDRS}" "${HDRS} ${EHDRS}")
 297   ALICE_SetPackageVariable(PCINTHDRS "CINTHDRS" "${CINTHDRS}" "${PH}")
 298
 299   string( REPLACE ".h" "" PCINTCLASSES "${PCINTHDRS}")
 300   set ( ${PACKAGE}CINTCLASSES ${PCINTCLASSES})
 301
 302   ALICE_SetPackageVariable(PDH "DH" "${DHDR}" "")
 303
 304   if(CINTAUTOLINK)
 305     ALICE_SetPackageVariable(PDAL "DAL" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h" "${CMAKE_CURRENT_BINARY_DIR}/G__${PACKAGE}AutoLinkDef.h")
 306     ALICE_SetPackageVariable(PDH "DH" "${PDAL}" "${PDAL}")
 307     ALICE_GenerateLinkDef()
 308   endif(CINTAUTOLINK)
 309
 310   if(lib)
 311     list(APPEND PMLIBS ${PACKAGE})
 312     list(APPEND ALLLIBS ${PACKAGE})
 313     list(APPEND PMALIBS ${PACKAGE}-static)
 314     list(APPEND ALLALIBS ${PACKAGE}-static)
 315     list(APPEND BINLIBS ${PACKAGE})
 316   else()
 317     list(APPEND ALLEXECS ${PACKAGE})
 318   endif(lib)
 319   set(${MODULE}ALIBS "${PMALIBS}" PARENT_SCOPE)
 320   set(${MODULE}LIBS "${PMLIBS}" PARENT_SCOPE)
 321   set(${MODULE}INC "${EINCLUDE}" PARENT_SCOPE)
 322   list(APPEND INCLUDEFILES ${PEXPORTDEST})
 323   if(WITHDICT)
 324     ALICE_SetPackageVariable(PDS "DS" "G__${PACKAGE}.cxx" "G__${PACKAGE}.cxx")
 325     ALICE_GenerateDictionary()
 326   else()
 327     if(lib)
 328       message(STATUS "No dictionary generated for ${PACKAGE}")
 329     endif(lib)
 330   endif(WITHDICT)
 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   ALICE_CopyHeaders()
 339   ALICE_BuildPAR()
 340
 341 endmacro(ALICE_BuildPackage)
 342
 343
 344 macro(ALICE_BuildModule)
 345
 346   add_definitions(-D_MODULE="${MODULE}")
 347   foreach(PACKAGEFILE ${PACKAGES})
 348       set(lib)
 349       set(bin)
 350       string(REGEX MATCH "CMakelib" lib "${PACKAGEFILE}")
 351       string(REGEX MATCH "CMakebin" bin "${PACKAGEFILE}")
 352       get_filename_component(PACKAGE ${PACKAGEFILE} NAME)
 353       string(REGEX REPLACE "^CMake(lib|bin)(.*)\\.pkg" "\\2" PACKAGE "${PACKAGE}")
 354       if(ALICEDEV)
 355         message("Adding package ${PACKAGE} in ${MODULE}")
 356       endif(ALICEDEV)
 357       ALICE_ResetPackage()
 358       include(${PACKAGEFILE})
 359       ALICE_BuildPackage()
 360
 361       get_property(EXCLUDEPACKAGE TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL)
 362       if(NOT EXCLUDEPACKAGE)
 363         install(TARGETS ${PACKAGE}
 364                 RUNTIME DESTINATION bin/tgt_${ALICE_TARGET}
 365                 LIBRARY DESTINATION lib/tgt_${ALICE_TARGET}
 366                 ARCHIVE DESTINATION bin/tgt_${ALICE_TARGET})
 367       endif(NOT EXCLUDEPACKAGE)
 368   endforeach(PACKAGEFILE)
 369   ALICE_CheckModule()
 370 endmacro(ALICE_BuildModule)
 371
 372 macro(ALICE_GenerateDictionary)
 373
 374   if(ALICEDEV STREQUAL "YES")
 375     message("Generating Dictionary rule for ${PACKAGE}")
 376     message("${ROOTCINT} -f ${PDS} -c ${PEDEFINE} ${CINTFLAGS} ${PINC} ${PCINTHDRS} ${PDH}")
 377   endif(ALICEDEV STREQUAL "YES")
 378
 379   # Split up all arguments
 380
 381   set(DEDEFINE ${PEDEFINE})
 382   set(DCINTFLAGS ${CINTFLAGS})
 383   set(DINC ${PINC})
 384   set(DCINTHDRS ${PCINTHDRS})
 385   set(DDH ${PDH})
 386   separate_arguments(DEDEFINE)
 387   separate_arguments(DCINTFLAGS)
 388   separate_arguments(DINC)
 389   separate_arguments(DCINTHDRS)
 390   separate_arguments(DDH)
 391   # Format neccesary arguments
 392   ALICE_Format(DINC "-I" "" "${DINC};${CMAKE_INCLUDE_EXPORT_DIRECTORY}")
 393   set_source_files_properties(${PDS} PROPERTIES GENERATED TRUE)
 394   set_source_files_properties(${PDS} PROPERTIES COMPILE_FLAGS "-w")
 395   add_custom_command(OUTPUT  ${PDS}
 396                      COMMAND cd ${PROJECT_SOURCE_DIR} && ${ROOTCINT} -f ${CMAKE_CURRENT_BINARY_DIR}/${PDS} -c -D_MODULE=\\\"${MODULE}\\\" ${DEDEFINE} ${DCINTFLAGS} ${DINC} ${DCINTHDRS} ${DDH}
 397                      WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
 398                      DEPENDS ${DCINTHDRS} ${DDH}
 399                      )
 400   add_custom_target(G${PACKAGE})
 401   add_dependencies(G${PACKAGE} ${PDS})
 402
 403 endmacro(ALICE_GenerateDictionary)
 404
 405 macro(ALICE_BuildLibrary)
 406
 407   ALICE_DevFlagsOutput()
 408   set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS}")
 409   set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS}")
 410   set(CMAKE_Fortran_FLAGS ${PEDEFINE} ${PFFLAGS})
 411   set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
 412   set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
 413
 414
 415   separate_arguments(PINC)
 416   separate_arguments(EINCLUDE)
 417   separate_arguments(PELIBSDIR)
 418   separate_arguments(PBLIBS)
 419   separate_arguments(PELIBS)
 420   separate_arguments(SHLIB)
 421
 422   ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
 423   ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
 424
 425   ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
 426   ALICE_CorrectPaths(PINC "${PINC}")
 427
 428   include_directories(SYSTEM ${ROOTINCDIR})
 429   include_directories(${PINC})
 430   include_directories(${EINCLUDE})
 431   include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
 432
 433   add_library(${PACKAGE} SHARED ${PCS} ${PFS} ${PS} ${PDS})
 434   set_target_properties(${PACKAGE} PROPERTIES SUFFIX .so)
 435
 436
 437   if(PELIBS OR SHLIB)
 438     target_link_libraries(${PACKAGE} ${PELIBSDIR} ${PELIBS} ${SHLIB})
 439   endif(PELIBS OR SHLIB)
 440
 441   add_dependencies(${MODULE}-all ${PACKAGE})
 442
 443   add_library(${PACKAGE}-static STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS})
 444   set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME ${PACKAGE})
 445   if(PELIBS OR ALLIB)
 446     target_link_libraries(${PACKAGE}-static ${PELIBSDIR} ${PELIBS} ${ALLIB})
 447   endif(PELIBS OR ALLIB)
 448
 449   add_dependencies(${MODULE}-all-static ${PACKAGE}-static)
 450   if(ALIPROFILE STREQUAL "YES")
 451     add_dependencies(${MODULE}-all ${MODULE}-static)
 452   endif(ALIPROFILE STREQUAL "YES")
 453
 454   list(FIND EXCLUDEMODULES ${MODULE} RESULT)
 455   if(NOT RESULT STREQUAL "-1")
 456     message(STATUS "${MODULE} will not be built by default. Type make ${MODULE}-all to build.")
 457     set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
 458   endif(NOT RESULT STREQUAL "-1")
 459
 460   set_target_properties(${PACKAGE} PROPERTIES INSTALL_NAME_DIR ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 461
 462 endmacro(ALICE_BuildLibrary)
 463
 464 macro(ALICE_BuildExecutable)
 465
 466   ALICE_DevFlagsOutput()
 467   set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS} ${EXEFLAGS}")
 468   set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS} ${EXEFLAGS}")
 469   set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS} ${EXEFLAGS}")
 470   set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
 471   set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
 472
 473   separate_arguments(PINC)
 474   separate_arguments(EINCLUDE)
 475   separate_arguments(PELIBSDIR)
 476   separate_arguments(PBLIBS)
 477   separate_arguments(PELIBS)
 478   separate_arguments(SHLIB)
 479
 480   ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
 481   ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
 482
 483   ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
 484   ALICE_CorrectPaths(PINC "${PINC}")
 485
 486   include_directories(SYSTEM ${ROOTINCDIR})
 487   include_directories(${PINC})
 488   include_directories(${EINCLUDE})
 489   include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
 490
 491   if(ALIPROFILE STREQUAL "YES")
 492     add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
 493     if(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
 494       target_link_libraries(${PACKAGE} ${ARLIBS} ${SHLIBS} ${PBLIBS} ${EXEFLAGS})
 495     endif(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
 496     add_dependencies(${MODULE}-all ${PACKAGE})
 497   else()
 498     add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
 499     if(PELIBS OR PBLIBS OR EXEFLAGS)
 500       target_link_libraries(${PACKAGE} ${BINLIBDIRS} ${PELIBSDIR} ${PELIBS} ${PBLIBS} ${EXEFLAGS})
 501     endif(PELIBS OR PBLIBS OR EXEFLAGS)
 502     add_dependencies(${MODULE}-all ${PACKAGE})
 503   endif(ALIPROFILE STREQUAL "YES")
 504
 505 # AliMDC
 506 # ------------------------------
 507   if(PACKAGE STREQUAL "alimdc" AND GENERATEPACKAGES)
 508
 509     add_executable(${PACKAGE}-static ${PFS} ${PCS} ${PS} ${PDS})
 510     set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME alimdca)
 511     add_custom_target( libAliMDC
 512                         COMMAND rm -rf ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a
 513                         COMMAND rm -rf junkmdc
 514                         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
 515                         WORKING_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 516     add_custom_target( root-static-libs
 517                        COMMAND make static
 518                        WORKING_DIRECTORY ${ROOTSYS} )
 519
 520     add_dependencies(libAliMDC RAWDatabase-static STEERBase-static MDC-static ESD-static)
 521     add_dependencies(${PACKAGE}-static libAliMDC root-static-libs)
 522     target_link_libraries(${PACKAGE}-static ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a ${ROOTLIBDIR}/libRoot.a ${ROOTLIBDIR}/libfreetype.a ${ROOTLIBDIR}/libpcre.a -pthread -ldl -lcurses)
 523
 524     install(TARGETS ${PACKAGE}-static RUNTIME DESTINATION bin/tgt_${ALICE_TARGET} COMPONENT MDC)
 525     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)
 526     install(FILES ${PROJECT_SOURCE_DIR}/RAW/mdc.h DESTINATION include COMPONENT MDC)
 527     set(CPACK_RPM_PACKAGE_SUMMARY "AliMDC static libraries")
 528     set(CPACK_RPM_PACKAGE_NAME "alimdc")
 529     set(CPACK_RPM_PACKAGE_VERSION "${ALIMDCVERSION}")
 530     set(CPACK_RPM_PACKAGE_RELEASE "${ALIMDCRELEASE}")
 531     set(CPACK_RPM_PACKAGE_LICENSE "License: CERN ALICE Off-line Group")
 532     set(CPACK_RPM_PACKAGE_VENDOR "ALICE Core Off-line Group")
 533     set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "AliMDC static libraries")
 534     set(CPACK_RPM_PACKAGE_GROUP "Applications/Alice")
 535     set(CPACK_RPM_PACKAGE_REQUIRES "glibc")
 536     set(CPACK_PACKAGE_VERSION "1.0.0")
 537     set(CPACK_PACKAGE_VERSION_MAJOR "1")
 538     set(CPACK_PACKAGE_VERSION_MINOR "0")
 539     set(CPACK_PACKAGE_VERSION_PATCH "0")
 540     set(CPACK_PACKAGE_INSTALL_DIRECTORY "/opt/")
 541     add_component_package(MDC alimdc-rpm)
 542
 543   endif(PACKAGE STREQUAL "alimdc" AND GENERATEPACKAGES)
 544
 545   list(FIND EXCLUDEMODULES ${MODULE} RESULT)
 546   if(NOT RESULT STREQUAL "-1")
 547     set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
 548   endif(NOT RESULT STREQUAL "-1")
 549
 550 endmacro(ALICE_BuildExecutable)
 551
 552 macro(ALICE_CopyHeaders)
 553
 554   if(EXPORT )
 555     set(HEADERS ${EXPORT})
 556     set(_headersdep)
 557     foreach(header ${HEADERS})
 558       add_custom_command(OUTPUT ${PEXPORTDEST}/${header}
 559                          COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_SOURCE_DIR}/${MODULE}/${header} ${PEXPORTDEST}/${header}
 560                          DEPENDS ${CMAKE_SOURCE_DIR}/${MODULE}/${header})
 561       list(APPEND _headersdep ${PEXPORTDEST}/${header})
 562       install(FILES ${header} DESTINATION include)
 563     endforeach(header)
 564     add_custom_target(${PACKAGE}-headers DEPENDS ${_headersdep})
 565     add_dependencies(${PACKAGE} ${PACKAGE}-headers)
 566   endif(EXPORT)
 567
 568 endmacro(ALICE_CopyHeaders)
 569
 570 macro(ALICE_GenerateLinkDef)
 571
 572   file (WRITE ${PDAL} "//--------------------------------------------------------------------------------\n")
 573   file (APPEND ${PDAL} "// This is an automatically generated Root Dictionary Linkdef file for ${PACKAGE}\n")
 574   file (APPEND ${PDAL} "// !!! DO NOT EDIT THIS FILE !!!\n")
 575   file (APPEND ${PDAL} "#ifdef __CINT__\n")
 576   file (APPEND ${PDAL} "#pragma link off all globals;\n")
 577   file (APPEND ${PDAL} "#pragma link off all classes;\n")
 578   file (APPEND ${PDAL} "#pragma link off all functions;\n")
 579   foreach (class ${PCINTCLASSES})
 580     get_filename_component(classname ${class} NAME)
 581     file(APPEND ${PDAL} "#pragma link C++ class ${classname}+;\n")
 582   endforeach(class)
 583   file (APPEND ${PDAL} "#endif\n")
 584 endmacro(ALICE_GenerateLinkDef)
 585
 586 macro(ALICE_BuildPAR)
 587
 588   if(EXISTS ${CMAKE_SOURCE_DIR}/${MODULE}/PROOF-INF.${PACKAGE})
 589     set(PARSRCS)
 590     foreach(file ${SRCS} ${HDRS} ${FSRCS} ${DHDR})
 591       get_filename_component(srcdir ${file} PATH)
 592       add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}-par
 593                          COMMAND mkdir -p ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${srcdir}
 594                          COMMAND cp -pR ${file} ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}
 595                          WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
 596       list(APPEND PARSRCS ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/${file}-par)
 597     endforeach(file ${SRCS} ${HDRS} ${FSRCS} ${DHDR})
 598
 599     add_custom_target(${PACKAGE}.par
 600                       COMMAND sed -e 's/include .\(ROOTSYS\)\\/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},' > ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/Makefile
 601                       COMMAND cp -pR ${ROOTSYS}/test/Makefile.arch ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/Makefile.arch
 602                       COMMAND cp -pR PROOF-INF.${PACKAGE} ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}/PROOF-INF
 603 #                      COMMAND cp -pR lib${PACKAGE}.pkg ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}
 604                       COMMAND ${CMAKE_COMMAND} -E chdir ${CMAKE_CURRENT_BINARY_DIR} tar --exclude=.svn -czhf ${CMAKE_BINARY_DIR}/${PACKAGE}.par ${PACKAGE}
 605                       COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_CURRENT_BINARY_DIR}/${PACKAGE}
 606                       COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --red --bold "${PACKAGE}.par has been created in ${CMAKE_BINARY_DIR}"
 607                       DEPENDS ${PARSRCS}
 608                       WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} )
 609
 610
 611     add_dependencies(${PACKAGE}.par ${SRCS} ${FSRCS} ${HDRS} ${DHDR})
 612     add_dependencies(par-all ${PACKAGE}.par)
 613     add_dependencies(${MODULE}-par-all ${PACKAGE}.par)
 614
 615     add_custom_target(test-${PACKAGE}.par
 616                       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}."
 617                       COMMAND ${CMAKE_COMMAND} -E make_directory par-tmp
 618                       COMMAND ${CMAKE_COMMAND} -E chdir par-tmp tar xfz ../${PACKAGE}.par && ${CMAKE_COMMAND} -E chdir par-tmp/${PACKAGE} PROOF-INF/BUILD.sh
 619                       COMMAND ${CMAKE_COMMAND} -E remove_directory par-tmp
 620                       COMMAND ${CMAKE_COMMAND} -E cmake_echo_color --green --bold "${PACKAGE}.par testing succeeded"
 621                       WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 622
 623     add_dependencies(test-${PACKAGE}.par ${PACKAGE}.par)
 624     add_dependencies(test-par-all test-${PACKAGE}.par)
 625     add_dependencies(test-${MODULE}-par-all test-${PACKAGE}.par)
 626
 627   endif(EXISTS ${CMAKE_SOURCE_DIR}/${MODULE}/PROOF-INF.${PACKAGE})
 628   # endif(EXISTS ${ALICE_ROOT}/${MODULE}/PROOF-INF.${PACKAGE})
 629
 630 endmacro(ALICE_BuildPAR)
 631