Completely reengineered version of CMake build system (Johny)
[u/mrichter/AliRoot.git] / 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 ${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})
314   else()
315     list(APPEND ALLEXECS ${PACKAGE})
316   endif(lib)
317
318   list(APPEND INCLUDEFILES ${PEXPORTDEST})
319   ALICE_CopyHeaders()
320   if(WITHDICT)  
321     ALICE_SetPackageVariable(PDS "DS" "G__${PACKAGE}.cxx" "G__${PACKAGE}.cxx")
322     ALICE_GenerateDictionary()
323   else()
324     if(lib)
325       message(STATUS "No dictionary generated for ${PACKAGE}")  
326     endif(lib)
327   endif(WITHDICT)
328   
329   if(PS OR PCS OR PFS)
330     if(lib)
331       ALICE_BuildLibrary()
332     elseif(bin)
333       ALICE_BuildExecutable()
334     endif(lib)
335   endif(PS OR PCS OR PFS)
336
337 endmacro(ALICE_BuildPackage)
338
339
340 macro(ALICE_BuildModule)
341
342   add_definitions(-D_MODULE="${MODULE}")
343   foreach(PACKAGEFILE ${PACKAGES})
344       set(lib)
345       set(bin)
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})
350       if(ALICEDEV)
351         message("Adding package ${PACKAGE} in ${MODULE}")
352       endif(ALICEDEV)
353       ALICE_ResetPackage()
354       include(${PACKAGEFILE})
355       ALICE_BuildPackage()
356      
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)
365
366 endmacro(ALICE_BuildModule)
367
368 macro(ALICE_GenerateDictionary)
369  
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")
374  
375   # Split up all arguments
376
377   set(DEDEFINE ${PEDEFINE})
378   set(DCINTFLAGS ${CINTFLAGS})
379   set(DINC ${PINC})
380   set(DCINTHDRS ${PCINTHDRS})
381   set(DDH ${PDH})
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}
394                      )
395   add_custom_target(G${PACKAGE})
396   add_dependencies(G${PACKAGE} ${PDS})
397
398 endmacro(ALICE_GenerateDictionary)
399
400 macro(ALICE_BuildLibrary)
401
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})
408   
409   
410   separate_arguments(PINC)
411   separate_arguments(EINCLUDE)
412   separate_arguments(PELIBSDIR)
413   separate_arguments(PBLIBS)
414   separate_arguments(PELIBS)
415   separate_arguments(SHLIB)
416
417   ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
418   ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
419   ALICE_CheckLibraries(PELIBS "${PELIBS}")
420
421   ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
422   ALICE_CorrectPaths(PINC "${PINC}")
423
424   include_directories(SYSTEM ${ROOTINCDIR})
425   include_directories(${PINC})  
426   include_directories(${EINCLUDE})
427   include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
428   
429   add_library(${PACKAGE} SHARED ${PCS} ${PFS} ${PS} ${PDS})
430   
431
432   if(PELIBS OR SHLIB)
433     target_link_libraries(${PACKAGE} ${PELIBSDIR} ${PELIBS} ${SHLIB})
434   endif(PELIBS OR SHLIB)
435   
436   add_dependencies(${MODULE}-all ${PACKAGE})
437      
438   add_library(${PACKAGE}_a STATIC EXCLUDE_FROM_ALL ${PCS} ${PFS} ${PS} ${PDS})
439   if(PELIBS OR ALLIB)
440     target_link_libraries(${PACKAGE}_a ${PELIBSDIR} ${PELIBS} ${ALLIB})
441   endif(PELIBS OR ALLIB)
442
443   add_dependencies(${MODULE}-static ${PACKAGE}_a)
444   if(ALIPROFILE STREQUAL "YES")
445     add_dependencies(${MODULE}-all ${MODULE}-static)
446   endif(ALIPROFILE STREQUAL "YES")
447
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")
453
454 endmacro(ALICE_BuildLibrary)
455
456 macro(ALICE_BuildExecutable)
457
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})
464   
465   separate_arguments(PINC)
466   separate_arguments(EINCLUDE)
467   separate_arguments(PELIBSDIR)
468   separate_arguments(PBLIBS)
469   separate_arguments(PELIBS)
470   separate_arguments(SHLIB)
471
472   ALICE_Format(PELIBSDIR "-L" "" "${PELIBSDIR}")
473   ALICE_CheckLibraries(PBLIBS "${PBLIBS}")
474   #ALICE_CheckLibraries(PELIBS "${PELIBS}")
475
476   ALICE_CorrectPaths(EINCLUDE "${EINCLUDE}")
477   ALICE_CorrectPaths(PINC "${PINC}")
478
479   include_directories(SYSTEM ${ROOTINCDIR})
480   include_directories(${PINC})  
481   include_directories(${EINCLUDE})
482   include_directories(${CMAKE_INCLUDE_EXPORT_DIRECTORY})
483
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})
490   else()
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")
497
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")
502
503 endmacro(ALICE_BuildExecutable)
504
505 macro(ALICE_CopyHeaders)
506   
507   if(NOT EXPORT )
508     set(HEADERS)
509   else()
510     set(HEADERS ${EXPORT})
511   endif(NOT EXPORT)
512   foreach(header ${HEADERS})
513       configure_file(${header} ${PEXPORTDEST} COPYONLY)
514       install(FILES ${header} DESTINATION include)
515   endforeach(header)
516
517 endmacro(ALICE_CopyHeaders)
518
519 macro(ALICE_GenerateLinkDef)
520
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")
531   endforeach(class)
532   file (APPEND ${PDAL} "#endif\n")
533 endmacro(ALICE_GenerateLinkDef)