cmake/ALICE_CMake.cmake

   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)
 309     list(APPEND PMLIBS ${PACKAGE})
 310     list(APPEND ALLLIBS ${PACKAGE})
 311     list(APPEND PMALIBS ${PACKAGE}-static)
 312     list(APPEND ALLALIBS ${PACKAGE}-static)
 313     list(APPEND BINLIBS ${PACKAGE})
 314   else()
 315     list(APPEND ALLEXECS ${PACKAGE})
 316   endif(lib)
 317   set(${MODULE}ALIBS "${PMALIBS}" PARENT_SCOPE)
 318   set(${MODULE}LIBS "${PMLIBS}" PARENT_SCOPE)
 319   set(${MODULE}INC "${EINCLUDE}" PARENT_SCOPE)
 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}-static STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS})
 441   set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME ${PACKAGE})
 442   if(PELIBS OR ALLIB)
 443     target_link_libraries(${PACKAGE}-static ${PELIBSDIR} ${PELIBS} ${ALLIB})
 444   endif(PELIBS OR ALLIB)
 445
 446   add_dependencies(${MODULE}-all-static ${PACKAGE}-static)
 447   if(ALIPROFILE STREQUAL "YES")
 448     add_dependencies(${MODULE}-all ${MODULE}-static)
 449   endif(ALIPROFILE STREQUAL "YES")
 450
 451   list(FIND EXCLUDEMODULES ${MODULE} RESULT)
 452   if(NOT RESULT STREQUAL "-1")
 453     message(STATUS "${MODULE} will not be built by default. Type make ${MODULE}-all to build.")
 454     set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
 455   endif(NOT RESULT STREQUAL "-1")
 456
 457 endmacro(ALICE_BuildLibrary)
 458
 459 macro(ALICE_BuildExecutable)
 460
 461   ALICE_DevFlagsOutput()
 462   set(CMAKE_CXX_FLAGS "${PEDEFINE} ${PCXXFLAGS} ${EXEFLAGS}")
 463   set(CMAKE_C_FLAGS "${PEDEFINE} ${PCFLAGS} ${EXEFLAGS}")
 464   set(CMAKE_Fortran_FLAGS "${PEDEFINE} ${PFFLAGS} ${EXEFLAGS}")
 465   set(CMAKE_SHARED_LINKER_FLAGS ${PSOFLAGS})
 466   set(CMAKE_MODULE_LINKER_FLAGS ${PLDFLAGS})
 467
 468   separate_arguments(PINC)
 469   separate_arguments(EINCLUDE)
 470   separate_arguments(PELIBSDIR)
 471   separate_arguments(PBLIBS)
 472   separate_arguments(PELIBS)
 473   separate_arguments(SHLIB)
 474
 475   ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
 476   ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
 477   #ALICE_CheckLibraries(PELIBS "${PELIBS}")
 478
 479   ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
 480   ALICE_CorrectPaths(PINC "${PINC}")
 481
 482   include_directories(SYSTEM ${ROOTINCDIR})
 483   include_directories(${PINC})
 484   include_directories(${EINCLUDE})
 485   include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
 486
 487   if(ALIPROFILE STREQUAL "YES")
 488     add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
 489     if(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
 490       target_link_libraries(${PACKAGE} ${ARLIBS} ${SHLIBS} ${PBLIBS} ${EXEFLAGS})
 491     endif(ARLIBS OR SHLIBS OR PBLIBS OR EXEFLAGS)
 492     add_dependencies(${MODULE}-all ${PACKAGE})
 493   else()
 494     add_executable(${PACKAGE} ${PFS} ${PCS} ${PS} ${PDS})
 495     if(PELIBS OR PBLIBS OR EXEFLAGS)
 496       target_link_libraries(${PACKAGE} ${BINLIBDIRS} ${PELIBSDIR} ${PELIBS} ${PBLIBS} ${EXEFLAGS})
 497     endif(PELIBS OR PBLIBS OR EXEFLAGS)
 498     add_dependencies(${MODULE}-all ${PACKAGE})
 499   endif(ALIPROFILE STREQUAL "YES")
 500
 501 # AliMDC
 502 # ------------------------------
 503   if(PACKAGE STREQUAL "alimdc")
 504
 505     add_executable(${PACKAGE}-static EXCLUDE_FROM_ALL ${PFS} ${PCS} ${PS} ${PDS})
 506     set_target_properties(${PACKAGE}-static PROPERTIES OUTPUT_NAME alimdca)
 507     add_custom_target( libAliMDC
 508                         COMMAND rm -rf ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a
 509                         COMMAND rm -rf junkmdc
 510                         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
 511                         WORKING_DIRECTORY ${CMAKE_LIBRARY_OUTPUT_DIRECTORY})
 512     add_custom_target( root-static-libs
 513                        COMMAND make static
 514                        WORKING_DIRECTORY ${ROOTSYS} )
 515
 516     add_dependencies(libAliMDC RAWDatabase-static STEERBase-static MDC-static ESD-static)
 517     add_dependencies(${PACKAGE}-static libAliMDC root-static-libs)
 518     target_link_libraries(${PACKAGE}-static ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libAliMDC.a ${ROOTLIBDIR}/libRoot.a ${ROOTLIBDIR}/libfreetype.a ${ROOTLIBDIR}/libpcre.a -pthread -ldl -lcurses)
 519
 520
 521
 522   endif(PACKAGE STREQUAL "alimdc")
 523
 524   list(FIND EXCLUDEMODULES ${MODULE} RESULT)
 525   if(NOT RESULT STREQUAL "-1")
 526     set_property(TARGET ${PACKAGE} PROPERTY EXCLUDE_FROM_ALL TRUE)
 527   endif(NOT RESULT STREQUAL "-1")
 528
 529 endmacro(ALICE_BuildExecutable)
 530
 531 macro(ALICE_CopyHeaders)
 532
 533   if(NOT EXPORT )
 534     set(HEADERS)
 535   else()
 536     set(HEADERS ${EXPORT})
 537   endif(NOT EXPORT)
 538   foreach(header ${HEADERS})
 539       configure_file(${header} ${PEXPORTDEST} COPYONLY)
 540       install(FILES ${header} DESTINATION include)
 541   endforeach(header)
 542
 543 endmacro(ALICE_CopyHeaders)
 544
 545 macro(ALICE_GenerateLinkDef)
 546
 547   file (WRITE ${PDAL} "//--------------------------------------------------------------------------------\n")
 548   file (APPEND ${PDAL} "// This is an automatically generated Root Dictionary Linkdef file for ${PACKAGE}\n")
 549   file (APPEND ${PDAL} "// !!! DO NOT EDIT THIS FILE !!!\n")
 550   file (APPEND ${PDAL} "#ifdef __CINT__\n")
 551   file (APPEND ${PDAL} "#pragma link off all globals;\n")
 552   file (APPEND ${PDAL} "#pragma link off all classes;\n")
 553   file (APPEND ${PDAL} "#pragma link off all functions;\n")
 554   foreach (class ${PCINTCLASSES})
 555     get_filename_component(classname ${class} NAME)
 556     file(APPEND ${PDAL} "#pragma link C++ class ${classname}+;\n")
 557   endforeach(class)
 558   file (APPEND ${PDAL} "#endif\n")
 559 endmacro(ALICE_GenerateLinkDef)