package GaudiPolicy
version v11r2

branches cmt doc

# LCG debug libraries are not distributed (LOCAL) ===========================
use LCG_Settings *
use Python * LCG_Interfaces -no_auto_imports

# Add Google malloc replacement to the LD_LIBRARY_PATH
use tcmalloc * LCG_Interfaces -no_auto_imports

# Note: Local installations except WinXP use the optimized versions of the AA
#       projects instead of the debug ones.
macro  LCG_platform      "$(LCG_platform)" \
       target-winxp      "$(LCG_platform)" \
       LOCAL&target-dbg  "$(LCG_system)" \
       LOCAL&target-cov  "$(LCG_system)"


# project strategies ========================================================
setup_strategy root

# global patterns ===========================================================

pattern -global include_none include_path none

pattern -global packageDir \
     macro <package>Dir "${<PACKAGE>ROOT}/${BINDIR}"


# include pattern ==========================================================

pattern install_more_includes \
    document install_more_includes install_more_includes more=<more> offset=<offset> ; \
    macro_prepend includes '' <project>_without_installarea ' $(ppcmd)"$(<package>_root)" ' ; \
    private ; \
    macro_prepend includes ' $(ppcmd)"$(<package>_root)" ' <project>_without_installarea '' ; \
    end_private

make_fragment install_more_includes -header=install_more_includes_header

cmtpath_pattern \
   macro <project>_home "<path>"

cmtpath_pattern_reverse \
   macro <project>_install_include "" \
         <project>_without_installarea "" \
         <project>_with_installarea&target-unix " <path>/$(<project>_installarea_prefix)$(shared_install_subdir)/include "\
         <project>_with_installarea&target-winxp ' "<path>\$(<project>_installarea_prefix)$(shared_install_subdir)\include"' ; \
   include_dirs ${<project>_install_include}

macro copyInclude "cp -Rup " \
      host-winxp  "xcopy /S/Q/Y/I/D " \
      host-darwin "cp -Rp"

macro ar            "$(ar)" \
      target-darwin "libtool -o"

# This command is not needed on MacOSX, being replaced via the libtool
# command (which is used instead of ar)
macro ranlib       "ranlib" \
     target-darwin "touch"


# standard patterns ================================================================
pattern Obj2Doth \
    document obj2doth  <package>Obj2Doth ../xml/*.xml

pattern packageOpts \
    set <PACKAGE>OPTS "$(<package>_root)/options" target-winxp "$(<package>_root)\options"

# coding conventions ========================================================

pattern  RuleChecker \
     document rule_checker <package>Chk -group=RuleChecker ../src/*.cpp ../src/Lib/*.cpp ../src/component/*.cpp


# library name dependent patterns============================================
#     the library name is given as an argument
#     example: apply_pattern libraryShr library=GaudiKernel

pattern libraryShr\
    set <library>Shr   "" \
        <project>_without_installarea&target-unix    "$(<package>Dir)/lib<library>" \
        <project>_without_installarea&target-winxp  "$(<package>Dir)\<library>"

pattern library_stamps \
    macro <package>_stamps "${<PACKAGE>ROOT}/${BINDIR}/<library>.stamp "

pattern library_shlibflags \
    macro <library>_shlibflags "$(libraryshr_linkopts)"

pattern library_Cshlibflags \
    private ; \
    macro <library>_shlibflags "$(componentshr_linkopts) $(cmt_installarea_linkopts) $(<library>_use_linkopts)  " ; \
    end_private

pattern library_Llinkopts \
    macro_append <package>_linkopts                 "" \
         <project>_with_installarea&target-unix     " -l<library> "\
         <project>_with_installarea&target-winxp    " <library>.lib "\
         <project>_without_installarea&target-unix  " -L$(<package>Dir) -l<library> "\
         <project>_without_installarea&target-winxp " $(<package>Dir)/<library>.lib "


pattern library_Lshlibflags \
    private ; \
    macro <library>_shlibflags "$(libraryshr_linkopts) $(cmt_installarea_linkopts) $(<library>_use_linkopts)" ; \
    macro_append <library>_shlibflags "" target-linux " -Wl,-soname=$(library_prefix)<library>.$(shlibsuffix) " ; \
    macro_remove <library>_use_linkopts "$(<package>_linkopts)" ; \
    end_private

pattern library_Softlinks \
    macro_append <package>_libraries              "" \
         <project>_without_installarea&target-unix " <library> "\
                 target-winxp                     ""

cmtpath_pattern \
    path_prepend DYLD_LIBRARY_PATH "" <project>_with_installarea&target-darwin "<path>/$(<project>_installarea_prefix)/$(tag)/lib"

pattern library_path \
    path_remove PATH ""  target-winxp "\<package>\" ; \
    path_prepend PATH ""  \
        <project>_without_installarea&target-winxp "${<package>_root}\${<package>_tag}" ; \
    path_remove DYLD_LIBRARY_PATH "" target-darwin "/<package>/" ; \
    path_append DYLD_LIBRARY_PATH "" \
        <project>_without_installarea&target-darwin "${<package>_root}/${<package>_tag}" ; \
    apply_pattern library_Softlinks library="<library>"


pattern component_library \
    apply_pattern libraryShr library="<library>" ; \
    apply_pattern library_Cshlibflags library="<library>" ;\
    macro <library>_dependencies "$(<package>_linker_library) " ;\
    apply_pattern generate_rootmap library=<library> group=<group> ; \
    apply_pattern generate_configurables library=<library> group=<group>

pattern linker_library \
    apply_pattern library_path        library="<library>" ; \
    apply_pattern library_Llinkopts   library="<library>" ; \
    apply_pattern library_Lshlibflags library="<library>" ; \
    apply_pattern library_stamps      library="<library>" ; \
    macro <package>_linker_library    "<library>" ; \
    private ; \
    macro_append lib_<library>_pp_cppflags " -DGAUDI_LINKER_LIBRARY " ; \
    macro <library>exportsymb "-export_all_symbols" target-winxp "-export_all_symbols" \
                              GAUDI_V21 "" GAUDI_V22 "" G21_HIDE_SYMBOLS ""; \
    macro <library>installlib  "yes" ; \
    end_private

#--------------------------------------------
# Patterns for specifically declaring and installing jobOptions files in the
# current installation area
#--------------------------------------------
make_fragment data_installer -header=data_installer_header

pattern declare_joboptions \
    macro_append <package>_joboptions " -s=../share <files> " ; \
    document data_installer install_<name>joboptions prefix=$(shared_install_subdir)/jobOptions $(<package>_joboptions) ; \
    macro_remove constituents " " target-winxp install_<name>joboptions

pattern declare_scripts \
    macro_append <package>_scripts " -s=$(<PACKAGE>ROOT)/share <files> " ; \
    document installer install_<name>scripts $(<package>_scripts) \
      install_dir=$(CMTINSTALLAREA)/share/bin install_command="'$(symlinknew)'"

#--------------------------------------------
# Patterns for specifically declaring and installing python files in the
# current installation area
#--------------------------------------------

cmtpath_pattern \
   macro <project>_install_python "" \
         <project>_without_installarea "" \
         <project>_with_installarea&target-unix&no-pyzip "<path>/$(<project>_installarea_prefix)$(shared_install_subdir)/python"\
         <project>_with_installarea&target-winxp&no-pyzip "<path>\$(<project>_installarea_prefix)$(shared_install_subdir)\python" \
         <project>_with_installarea&target-unix "<path>/$(<project>_installarea_prefix)$(shared_install_subdir)/python.zip" \
         <project>_with_installarea&target-winxp "<path>\$(<project>_installarea_prefix)$(shared_install_subdir)\python.zip" ; \
    path_remove  PYTHONPATH ${<project>_install_python} ; \
    path_prepend PYTHONPATH ${<project>_install_python}


pattern declare_python_modules \
    macro_append <package>_python_modules " -s=../python <files> " ; \
    document data_installer install_<name>python_modules prefix=python $(<package>_python_modules) ; \
    macro_remove constituents " " target-winxp install_<name>python_modules


pattern install_python_modules \
    macro <package>_install_python "" \
         <project>_without_installarea&target-unix "$(<package>_root)/python" \
         <project>_without_installarea&target-winxp "$(<package>_root)\python" ; \
    path_remove  PYTHONPATH ${<package>_install_python} ; \
    path_prepend PYTHONPATH ${<package>_install_python} ; \
    document install_python <package>_python ; \
    apply_pattern genconfuser ; \
    apply_pattern install_python_init ; \
    macro_append <package>_python_init_dependencies " <package>_python " ;

pattern install_custom_python_modules \
    macro <package>_install_python "" \
         <project>_without_installarea&target-unix "$(<package>_root)/<source>" \
         <project>_without_installarea&target-winxp "$(<package>_root)\<source>" ; \
    path_remove  PYTHONPATH ${<package>_install_python} ; \
    path_prepend PYTHONPATH ${<package>_install_python} ; \
    document install_python <package>_<source>_<offset>_python source=<source> offset=<offset> ; \
    apply_pattern install_python_init ; \
    macro_append <package>_python_init_dependencies " <package>_<source>_<offset>_python " ;

make_fragment install_python -header=install_python_header

pattern install_python_init \
	document python_init <group><package>_python_init -group=<group> package=<group><package> ; \
	apply_pattern zip_python_modules package=<package> group=<group> ; \
  	macro_append zip_<group><package>_python_modules_dependencies " <group><package>_python_init "

make_fragment python_init -header=python_init_header

#-------------------------------------------------------------------
# Pattern: pyd_module, pyd_boost_module
#   Creates a Python extension binary modules with the "so" (or "pyd" on Win) file extension.
#   The version 'pyd_boost_module' should be used in case the module
#   uses Boost.Python (http://www.boost.org/doc/libs/release/libs/python/doc/).
#
# Parameters:
#
#   module:  name of the final python module
#   files:   source files of the module
#   deps:    targets to be build before the module (e.g. the linker library)
#
# Usage:
#
#   use Python * LCG_Interfaces -no_auto_imports
#   apply_pattern pyd_module module=MyPyModule files=MyPyModule/*.cpp deps=MyPackageLib
#
#   use Python * LCG_Interfaces -no_auto_imports
#   use Boost * LCG_Interfaces -no_auto_imports
#   apply_pattern pyd_boost_module module=MyPyModule files=MyPyModule/*.cpp deps=MyPackageLib
#
# Notes:
#
#   The python binary module is linked by default against the linker library
#   in the package, so, if there is one, it is mandatory either to specify
#   the 'deps' parameter or to remove the link options from <module>_use_linkopts,
#   e.g.:
#
#      macro_remove MyPyModule_use_linkopts '$(MyPackage_linkopts)'
#
#   As well, additional libraries needed by the module (or link options) must be
#   added to the macro <module>_shlibflags.
#
#-------------------------------------------------------------------
# Macro used to define where Python binary modules have to be installed
macro python_bin_module_dir '$(tag)/python/lib-dynload' \
               target-winxp '$(tag)\python\lib-dynload' \
 use-shared-dir&target-winxp '$(tag)\python' \
              use-shared-dir '$(tag)/python'

# Main pattern
pattern pyd_module \
  macro <package>_install_pyd_module "" \
        <project>_without_installarea&target-unix "$(<package>_root)/$(tag)" \
        <project>_without_installarea&target-winxp "$(<package>_root)\$(tag)" ; \
  path_remove  PYTHONPATH $(<package>_install_pyd_module) ; \
  path_prepend PYTHONPATH $(<package>_install_pyd_module) ; \
  macro <module>_shlibflags  "$(libraryshr_linkopts) $(cmt_installarea_linkopts) $(<module>_use_linkopts)" ;\
  macro_append <module>_dependencies " <name> <deps> " ; \
  private ; \
  macro shlibsuffix "$(shlibsuffix)" target_<module>&target-winxp "pyd" ; \
  macro library_prefix "$(library_prefix)" target_<module> "" ; \
  macro <module>_install_dir "$(CMTINSTALLAREA)/$(python_bin_module_dir)" target-winxp "$(CMTINSTALLAREA)\$(python_bin_module_dir)" ; \
  library <module> -no_static -import=Python -target_tag install_dir="$(<module>_install_dir)" <files> ; \
  end_private ; \
  macro_append <module>_cppflags " -ftemplate-depth-64" target-winxp "" ;
# Boost version of the pattern
pattern pyd_boost_module \
  apply_pattern pyd_module module=<module> files=<files> deps=<deps> name=<name> ; \
  macro_append <module>_use_linkopts " $(Boost_linkopts_python)"

cmtpath_pattern \
   macro <project>_install_pyd_module "" \
         <project>_without_installarea "" \
         <project>_with_installarea&target-unix "<path>/$(<project>_installarea_prefix)/$(python_bin_module_dir)" \
         <project>_with_installarea&target-winxp "<path>\$(<project>_installarea_prefix)\$(python_bin_module_dir)" ; \
    path_remove  PYTHONPATH $(<project>_install_pyd_module) ; \
    path_prepend PYTHONPATH $(<project>_install_pyd_module) ;
#-------------------------------------------------------------------


action CompilePython "python -m compileall $(CMTINSTALLAREA)$(shared_install_subdir)/python $(CMTINSTALLAREA)$(shared_install_subdir)/scripts" \
	    target-winxp "python -m compileall $(CMTINSTALLAREA)$(shared_install_subdir)\python $(CMTINSTALLAREA)$(shared_install_subdir)\scripts"

macro_remove cmt_actions_constituents "CompilePython "
macro_remove cmt_actions_constituentsclean "CompilePythonclean "

#--------------------------------------------
# Patterns for specifically declaring and installing script files in the
# current installation area
#--------------------------------------------

cmtpath_pattern \
   macro scripts_offset "." ; \
   macro scripts_maindir "scripts" ; \
   macro scripts_dir "$(scripts_maindir)"

#cmtpath_pattern \
#   macro scripts_offset "share" ; \
#   macro scripts_maindir "bin" ; \
#   macro scripts_dir "$(scripts_offset)/$(scripts_maindir)" target-winxp "$(scripts_offset)\$(scripts_maindir)"

cmtpath_pattern \
   macro <project>_install_scripts "" \
         <project>_without_installarea "" \
         <project>_with_installarea&target-unix "<path>/$(<project>_installarea_prefix)$(shared_install_subdir)/$(scripts_dir)"\
         <project>_with_installarea&target-winxp "<path>\$(<project>_installarea_prefix)$(shared_install_subdir)\$(scripts_dir)" ; \
    path_remove  PATH ${<project>_install_scripts} ; \
    path_prepend PATH ${<project>_install_scripts}

pattern install_scripts \
    macro <package>_install_scripts "" \
         <project>_without_installarea&target-unix "$(<package>_root)/$(scripts_dir)" \
         <project>_without_installarea&target-winxp "$(<package>_root)\$(scripts_dir)" ; \
    path_remove  PATH ${<package>_install_scripts} ; \
    path_prepend PATH ${<package>_install_scripts} ; \
    document install_scripts install_scripts source=$(scripts_dir) offset=$(scripts_offset)


make_fragment install_scripts -header=install_scripts_header



#--------------------------------------------
# Patterns for declaring and installing run-time files in the ../run
# directory of the current package
#
#  Change in the syntax : the extras parameter is becoming obsolete and is
#  replaced with files extras is kept for backward compatibility but will
#  soon be made obsolete
#--------------------------------------------

#
# Some data files are specified using a directory.
#
macro install_command 'python $(GaudiPolicy_root)/scripts/install.py -xCVS -x*~ -x*.stamp -x*.bak -x.* -x*.pyc -x*.pyo --log=./install.$(tag).history '
macro uninstall_command 'python $(GaudiPolicy_root)/scripts/install.py -u --log=./install.$(tag).history '

macro remove_command "$(cmt_uninstallarea_command)"

macro library_install_command "python $(GaudiPolicy_root)/scripts/install.py -xCVS -x*~ -x*.stamp -x*.bak -x.* -x*.pyc -x*.pyo -s --log=./install.$(tag).history " \
      host-winxp              "copy "
macro cmt_installarea_command "python $(GaudiPolicy_root)/scripts/install.py -xCVS -x*~ -x*.stamp -x*.bak -x.* -x*.pyc -x*.pyo -s --log=./install.$(tag).history " \
      host-winxp              "xcopy /S /E /Y "

pattern declare_runtime \
    macro_append <package>_runtime " -s=../share <files> <extras> " ; \
    macro_append use_runtime " $(<package>_runtime) " ; \
    document installer install_<name>runtime $(<package>_runtime) \
      install_dir=$(CMTINSTALLAREA)/share

pattern declare_runtime_extras \
    apply_pattern declare_runtime files="<files>" extras="<extras>" name="<name>"

pattern install_runtime \
    macro data "$(use_runtime)" ; \
    document get_files <name>get_files install_dir=../run/ copymethod=<method>



make_fragment get_files -header=get_files_header

pattern get_files \
    macro <name>jo "<jo>" ; \
    macro <name>scripts "<scripts>" ; \
    macro <name>data "<data>" ; \
    macro <name>xmls "<xmls>" ; \
    document get_files <name>get_files install_dir=../run/ copymethod=<method> name=<name>




# ===== special cases: the library name is derived from the package name ====
#                   <package> and <package>Lib

# <package> linker library patterns ==========================================


pattern package_stamps \
    apply_pattern library_stamps library="<package>"

pattern package_linkopts \
    apply_pattern library_Llinkopts library="<package>"

pattern package_shlibflags \
    apply_pattern library_Lshlibflags library="<package>"

pattern package_libraries \
    apply_pattern library_Softlinks library="<package> <package>Lib <package>Dict"


# <package> component library patterns ========================================

pattern packageShr \
    apply_pattern libraryShr library="<package>"

pattern package_Cshlibflags \
    apply_pattern library_Cshlibflags library="<package>"


# <package>Lib linker library built with a <package> component library========

pattern package_Lstamps \
    apply_pattern library_stamps library="<package>Lib"

pattern package_Llinkopts \
    apply_pattern library_Llinkopts library="<package>Lib"

pattern package_Lshlibflags \
    apply_pattern library_shlibflags library="<package>Lib"

# <package> static library patterns ========================================

pattern package_Slinkopts \
macro <package>_linkopts "$(<package>Dir)/lib<package>.a -u <package>_loadRef"\
       target-winxp      "$(<package>Dir)/<package>.lib /include:_<package>_loadRef "

# <package> Fortran library patterns =======================================

pattern package_Flinkopts \
    macro <package>_linkopts "$(<package>Dir)/lib<package>.a "\
              target-winxp   "$(<package>Dir)/<package>.lib "

macro dq '"'
pattern package_fflags \
  macro <package>_fflags   ' ' \
      target-winxp '/fpp:$(dq)/I$(<PACKAGE>ROOT)$(dq) /fpp:$(dq)/I$(<PACKAGE>ROOT)/src$(dq)'

# handle LD_LIBRARY_PATH ====================================================

pattern ld_library_path \
    path_remove LD_LIBRARY_PATH "/<package>/" target-winxp "" ; \
    path_append LD_LIBRARY_PATH ""\
        <project>_without_installarea&target-unix   "${<package>_root}/${<package>_tag}" ; \
    path_remove PATH "" target-winxp  "\<package>\" ; \
    path_prepend PATH "" \
        <project>_without_installarea&target-winxp   "${<package>_root}/${<package>_tag}" ; \
    path_remove DYLD_LIBRARY_PATH "" target-darwin "/<package>/" ; \
    path_append DYLD_LIBRARY_PATH "" \
        <project>_without_installarea&target-darwin "${<package>_root}/${<package>_tag}"

# to add the application_path to LD_LIBRARY_PATH on target-unix
pattern application_path \
    path_remove  LD_LIBRARY_PATH  "/<package>/" target-winxp "" ; \
    path_prepend LD_LIBRARY_PATH  "" \
        <project>_without_installarea&target-unix "${<package>_root}/$(<package>_tag)"

pattern generate_rootmap \
  document genmap <library>RootMap -group=<group> LIBNAME=<library> ; \
  macro_append <library>RootMap_dependencies " <library> " ; \
  private ; \
    apply_pattern application_path ; \
    macro merge_rootmap_tag "--do-merge"   \
	  do_merge_rootmap  "--do-merge"   \
	  no_merge_rootmap  "--un-merge" ; \
    document merge_rootmap <library>MergeMap -group=<group> \
             library=<library> \
             merge_rootmap_switch=$(merge_rootmap_tag) \
             $(bin)$(library_prefix)<library>.$(shlibsuffix) ; \
    macro_append <library>MergeMap_dependencies " <library>RootMap " ; \
  end_private


# Tags and Global macros=====================================================

macro BINDIR              "$(tag)"

# Specify Common Unix tag associations
tag host-darwin    host-unix

# SL5 to SLC5 mapping (should go in LCG_Settings in LCG 57b)
tag sl51   host-slc5
tag sl52   host-slc5
tag sl53   host-slc5
tag sl54   host-slc5
tag sl55   host-slc5
tag sl56   host-slc5
tag sl57   host-slc5
# Atlas uses shared directories
tag ATLAS  use-shared-dir

# Fragments =================================================================

# MS DeveloperStudio
make_fragment dsp_application_header
make_fragment dsp_library_header
make_fragment dsp_all

# make fragment for the rule checker
make_fragment rule_checker -header=rule_checker_header -trailer=rule_checker_trailer -suffix=viol
make_fragment rule_checker_trailer

# vsnet fragments, which override premature efforts now in CMT v1r14
make_fragment vcproj_library_header
make_fragment vcproj_application_header
make_fragment vcproj_all
make_fragment vcproj_trailer
make_fragment vcproj_contents
make_fragment vcproj_directory_header
make_fragment vcproj_directory_trailer

make_fragment sln_header
make_fragment sln_project
make_fragment sln_trailer
make_fragment sln_project_config
make_fragment sln_dependency_project

make_fragment sln_dependency_header
make_fragment sln_dependency_trailer


# C++
# The cpp fragments for enhanced computation of dependencies are not available on Windows
macro cpp_fragment "cpp" target-winxp ""
make_fragment $(cpp_fragment)
macro cpp_library_fragment "cpp_library" target-winxp ""
make_fragment $(cpp_library_fragment)

macro cmt_compiler_version "${cmt_compiler_version}" \
              target-gcc43 "gcc43"

macro cppcomp         "$(cpp) -c $(cppdebugflags) $(cppflags) $(pp_cppflags) $(includes)" \
      VisualC         "cl.exe $(cppdebugflags) $(cppflags) $(pp_cppflags)"


# Local copy of the dependencies fragment to allow a "QUICK" option that
# completely ignores dependencies (useful to speed up builds from scratch).
macro dep_fragment "" CMTp20070208 "dependencies"
make_fragment $(dep_fragment)

# Local copy of the application fragment to be able to use VC9 (embed manifest in executables)
macro app_fragment "" target-winxp&target-vc9 "application"
make_fragment $(app_fragment)

macro vsCONFIG   "Release"   target-dbg  "Debug"
macro vsDebug    "2"         target-dbg  "1"
macro vsOptimize "2"         target-dbg  "0"
# The vsnet generated files are not correct for VC++9, so it is better
# to claim that they are for VC++7.1 and let VC++9 do the conversion
macro vsVersion  ""   vc++7.1  "7.10"  vc++7.0 "7.00"  vc++9 "7.10"
macro package_GUID "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}"
macro GUID_all "{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC955}"

macro make_shlib    "echo" \
      HP-UX         "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
      OSF1          "${CMTROOT}/mgr/cmt_make_shlib_common.sh noextract" \
      host-linux  "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
      CYGWIN        "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
      SunOS         "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
      host-darwin "${CMTROOT}/mgr/cmt_make_shlib_common.sh extract" \
      host-visualc "$(GAUDIPOLICYROOT)\cmt\cmt_make_shlib.bat"

macro merge_rootmap_cmd "python $(GaudiPolicy_root)/scripts/merge_files.py" \
           target-winxp "$(GaudiPolicy_root)/scripts/merge_files.py"
make_fragment merge_rootmap -header=merge_rootmap_header
macro libdirname "lib" # defaults for fragments of libs and bins
macro bindirname "bin" # defaults for fragments of libs and bins

# Override library fragment
# Needed only for Windows, but it must be present for Unix too, so we included
# a version working for CMT v1r20p20070208 and v1r20p20090520 (only on WinXP)
macro lib_fragment "" \
       CMTp20070208 "library -header=library_header -dependencies" \
       CMTp20090520&target-winxp "library -header=library_header -dependencies"
make_fragment $(lib_fragment)
macro lib_no_static_fragment "" \
       CMTp20070208&target-winxp "library_no_static" \
       CMTp20090520&target-winxp "library_no_static" \
       CMTr20&target-unix "" \
       target-unix "library_no_static"
make_fragment $(lib_no_static_fragment)

# Compilation and Linking flags==============================================

# C++ compiler
macro_prepend  cpp_name "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "lcg-"
macro_append   cpp_name "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "-$(gcc_config_version)"
macro cpp_name "$(cpp_name)" target-icc "icpc"

# C compiler
macro_prepend  cc_name  "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "lcg-"
macro_append   cc_name  "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "-$(gcc_config_version)"

# FORTRAN compiler
macro_prepend  for_name "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "lcg-"
macro_append   for_name "" \
    lcg-compiler&target-gcc&CERNDISTCC "" \
    lcg-compiler&target-gccmax    "" \
    lcg-compiler&target-gcc       "-$(gcc_config_version)"

# C++ debug, optimized and profiled options
macro cppdebugflags    "" \
      target-dbg        "$(cppdebugflags_s)"\
      target-opt        "$(cppoptimized_s)"
macro cppdebugflags_s  "-g" \
      target-winxp            "/Od /Z7"
macro cppoptimized_s   "-O2 -DNDEBUG" \
      target-winxp            ""
macro cppprofiled_s   "-pg" \
      target-winxp            ""
macro_append cppdebugflags "" \
      target-pro        " $(cppprofiled_s)"

# C debug, optimized and profiled options
macro cdebugflags     "" \
      target-dbg           "$(cdebugflags_s)" \
      target-dbg           "$(coptimized_s)"
macro cdebugflags_s   "-g" \
      target-winxp           "/Od /Z7"
macro coptimized_s    "-O2 -DNDEBUG" \
      target-winxp    ""

# Fortran debug, optimized and profiled options
macro fdebugflags      "" \
      target-dbg            "$(fdebugflags_s)"
macro fdebugflags_s    "-g"\
      target-winxp            "/nopdbfile /debug:full /optimize:0"
macro foptimized_s     "-O2 -DNDEBUG" \
      target-winxp            ""
macro_append fdebugflags "" \
      target-opt        " $(foptimized_s)"
macro fprofiled_s      "-pg" \
      target-winxp            ""
macro_append fdebugflags "" \
      target-pro        " $(fprofiled_s)"

# Link debug options
macro linkdebugflags   "" \
      target-dbg            "$(linkdebugflags_s)"
macro linkdebugflags_s "" \
      target-winxp            "/debug /verbose:lib "

# gcov special option (added to LCG_Platforms_linkopts because it is the last macro in the
# link options and --coverage must appear very late on the command line).
macro_append LCG_Platforms_linkopts "" \
                         target-cov " --coverage"
macro_append LCG_Platforms_cppflags "" \
                         target-cov " --coverage"
macro_append LCG_Platforms_cflags "" \
                       target-cov " --coverage"
macro_append LCG_Platforms_fflags "" \
                       target-cov " --coverage"

macro cppflags         " -fmessage-length=0 -Df2cFortran -fPIC -shared -D_GNU_SOURCE -Dlinux -Dunix -pipe -ansi -Wall -Wextra -pthread " \
      target-mac105    " -Df2cFortran -fPIC -D_GNU_SOURCE -Dunix -pipe -ansi -Wall -Wextra -Wno-long-double " \
      target-mac106    " -Df2cFortran -fPIC -D_GNU_SOURCE -Dunix -pipe -ansi -Wall -Wextra " \
      target-vc9       '$(includes) /D "WIN32" /D "_MBCS"  /D "_WINDOWS" /FD /c /nologo /W3 /EHsc /MD /GR /Zm500' \
      target-vc7       '$(includes) /D "WIN32" /D "_MBCS"  /D "_WINDOWS" /FD /c /nologo /W3 /GX /MD /GR /Zm500'

##############################################################################
# Intel compiler support
macro_remove cppflags "" target-icc "-pedantic"
macro_remove cppflags "" target-icc "-Wextra"
macro_remove cppflags "" target-icc "-Wno-long-long"
### Disable some non interesting "remarks" (inspired by CoolKernel)
# Permanently disabled
#  - remark #383:  valued copied to temporary, reference to temporary
macro_append cppflags '' target-icc '-wd383 '
#  - remark #981:  operands are evaluated in unspecified order
macro_append cppflags '' target-icc '-wd981 '
#  - remark #1418: external function definition with no prior declaration
macro_append cppflags '' target-icc '-wd1418 '
#  - remark #1419: external declaration in primary source file
#                  (triggers on forward declarations in a .cpp)
macro_append cppflags '' target-icc '-wd1419 '
# Non permanent
#  - remark #82:     storage class is not first
#                    (appears only once in ROOT)
macro_append cppflags '' no-hide-warnings '' target-icc '-wd82 '
#  - remark #522:    function "X" redeclared "inline" after being called
#                    (fixed those in Gaudi, but a lot are coming from ROOT, Reflex and HepPDT)
macro_append cppflags '' no-hide-warnings '' target-icc '-wd522 '
#  - remark #444:    destructor for base class "X" is not virtual
#                    (gives a lot of fals positives, e.g. std::unary_function)
macro_append cppflags '' no-hide-warnings '' target-icc '-wd444 '
#  - remark #304:    access control not specified ("public/private" by default)
#                    (fixed one in GaudiKernel, but most are from Boost)
macro_append cppflags '' no-hide-warnings '' target-icc '-wd304 '
#  - Hide deprecation warnings (due to the usage of hash_map, unavoidable because of gccxml)
macro_append cppflags '' no-hide-warnings '' target-icc '-Wno-deprecated '
### Special link option to avoid the warning:
#     'libimf.so: warning: warning: feupdateenv is not implemented and will always fail'
#   Note: we use this macro because it is the only one that is used in the
#   right place in the command line options of (every) executable
macro_append GaudiKernel_linkopts '' target-icc '-limf -lm '
##############################################################################

# macro_append cppflags " -msse2 -mfpmath=sse" \
#             target-winxp    " /arch:SSE2"

macro_append cppflags "" \
      GAUDI_V21&target-gcc4 " -fvisibility=hidden -fvisibility-inlines-hidden " \
      G21_HIDE_SYMBOLS&target-gcc4 " -fvisibility=hidden -fvisibility-inlines-hidden "

# Use Gaudi v20 compatibility mode unless we have the extra tag GAUDI_V21
macro_append pp_cppflags  " -DGAUDI_V20_COMPAT " \
             GAUDI_V21    "" \
             GAUDI_V22    " -DGAUDI_V22_API "
macro_append pp_cppflags "" \
      G21_NEW_INTERFACES " -DG21_NEW_INTERFACES "
macro_append pp_cppflags "" \
        G21_HIDE_SYMBOLS " -DG21_HIDE_SYMBOLS "
macro_append pp_cppflags "" \
           G21_NO_ENDREQ " -DG21_NO_ENDREQ "
macro_append pp_cppflags "" \
       G21_NO_DEPRECATED " -DG21_NO_DEPRECATED "
macro_append pp_cppflags "" \
      G22_NEW_SVCLOCATOR " -DG22_NEW_SVCLOCATOR "

macro_append cppflags       "" \
      host-x86_64&target-i386 " -m32" \
      host-x86_64&target-i686 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

# ---- Disable warnings coming from external libraries
#      the hacks can be disabled with the tag "no-hide-warnings".
# FIXME: (MCl) Temporary work-around until gccxml understands unordered_map
macro_append cppflags "" \
         no-hide-warnings "" \
         target-gcc43 " -Wno-deprecated"
# FIXME: (MCl)
macro_append cppflags "" \
         no-hide-warnings "" \
         target-gcc43 " -Wno-empty-body"

# ppcmd=-I can be used on Windows as on Linux
macro ppcmd "-I"

# Fortran compiler
macro for_name      "gfortran" \
      target-slc4   "g77" \
      target-darwin "gfortran -ff2c" \
      target-winxp  "f77.exe"

macro for "$(for_name)"

macro_append shlibflags ""\
      host-x86_64&target-i686 " -m32" \
      host-x86_64&target-i386 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

macro fflags           "-fmessage-length=0 -O2 -fdollar-ok -ff90 -w -fPIC" \
      target-gcc4      "-fmessage-length=0 -O2 -fdollar-ok -w -fPIC" \
      target-darwin    "-fno-automatic -fdollar-ok -w" \
      target-winxp     '/compile_only /nologo /warn:nofileopt /warn:nouncalled /fpp:"/m" /fpp:"/I.." '

macro_append fflags  ""  \
      host-x86_64&target-i686 " -m32" \
      host-x86_64&target-i386 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

# macro_append fflags " -msse2 -mfpmath=sse" \
#             target-winxp    " "

macro fcomp            "$(for) -c $(fincludes) $(fdebugflags) $(fflags) $(pp_fflags)" \
      target-winxp     "$(for) $(fdebugflags) $(fflags) $(pp_fflags)"

# C compiler

macro_append cflags " -fmessage-length=0 -fPIC " \
             target-winxp    " "

macro_append cflags  "" \
      host-x86_64&target-i686 " -m32" \
      host-x86_64&target-i386 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

# macro_append cflags " -msse2 -mfpmath=sse" \
#             target-winxp    " /arch:SSE2"

# Link options

# Note that we can't perform strict static linking since some external
# packages do not provide static libraries. Thus the only possible
# strategy is to use a dynamic link strategy, but to link against the
# explicit static libraries (using <path>/lib<pkg>.a) where feasible.
# The following allows for potential platform-specific overrides of the
# defaults.

macro makeLinkMap            ""\
      target-linux           "-Wl,-Map,Linux.map"\
      target-winxp           "/map"

macro cpplinkflags "" \
      target-linux "-Wl,-Bdynamic $(linkdebugflags) -ldl -Wl,--as-needed " \
      target-vc    "/nologo /machine:ix86 $(linkdebugflags) $(makeLinkMap) /nodefaultlib kernel32.lib user32.lib ws2_32.lib advapi32.lib shell32.lib msvcrt.lib msvcprt.lib oldnames.lib "

macro_append cpplinkflags "" \
      target-linux               "-Wl,--no-undefined "

macro_remove shlibflags "" \
      target-mac "-undefined suppress"

macro_append cpplinkflags  "" \
      host-x86_64&target-i686 " -m32" \
      host-x86_64&target-i386 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

macro_append cpplinkflags "" \
      target-cov " $(linkdebugflags) "

macro_append cpplinkflags "" \
      target-pro        " $(cppprofiled_s)"

macro cpplink         "$(cpp) $(cpplinkflags)" \
      target-winxp           "link.exe $(cpplinkflags)"

macro componentshr_linkopts "" \
      target-linux          "-fPIC -ldl -Wl,--as-needed " \
      target-winxp          "/DLL "

macro_append componentshr_linkopts "" \
      target-linux                 "-Wl,--no-undefined "

macro_append componentshr_linkopts "" \
      target-linux&target-opt&strip-symbols "-Wl,-s "

macro_append componentshr_linkopts "" \
      target-cov  " $(linkdebugflags) "

macro_append componentshr_linkopts   "" \
      host-x86_64&target-i686 " -m32" \
      host-x86_64&target-i386 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

macro libraryshr_linkopts   "" \
      target-linux          "-fPIC -ldl -Wl,--as-needed " \
      target-winxp          "/DLL"

macro_append libraryshr_linkopts "" \
      target-linux               "-Wl,--no-undefined "

macro_append libraryshr_linkopts   "" \
	  target-cov  " $(linkdebugflags) "

macro_append libraryshr_linkopts   "" \
      host-x86_64&target-i386 " -m32" \
      host-x86_64&target-i686 " -m32" \
      host-darwin&target-i386 " -m32" \
      host-i686&target-x86_64 " -m64" \
      host-i386&target-x86_64 " -m64"

# Add 64-bit link options for SLC5. This overrides the default library segment
# alignment of 1MB
macro_append componentshr_linkopts       "" \
      target-gcc&host-slc5&target-x86_64 " -Wl,-z,max-page-size=0x1000 "
macro_append libraryshr_linkopts         "" \
      target-gcc&host-slc5&target-x86_64 " -Wl,-z,max-page-size=0x1000 "

macro application_linkopts  "" \
      target-linux                 "-Wl,--export-dynamic "

macro shlibsuffix   "so" \
      target-winxp         "dll"


#cmtpath_pattern \
#   path_prepend PATH <path>/$(cmt_installarea_prefix)/share/bin

#private

#apply_pattern get_files scripts=symlink.sh name=GaudiPolicy

#macro GaudiPolicy_CMT_files "../src/symlink.sh"

#-------------------------------------------------------------------
# Shared installation options
#   if the extra tag use-shared-dir is specified, the
#   platform-independent files will be installed in shared
#   directories in the InstallArea
#-------------------------------------------------------------------
macro shared_install_subdir '/$(tag)' \
               target-winxp '\$(tag)' \
             use-shared-dir ''

#-------------------------------------------------------------------
# begin of genconf
#-------------------------------------------------------------------
public

#
# to disable genconf for a package add to the requirements file:
#
# private
#  apply_tag no_genconf
# end_private
#
# Conversely, to explicitly enable the configurable generation for a package:
# private
#  apply_tag do_genconf
# end_private
#

macro genconfDir    "/genConf/" \
      target-winxp         "\genConf\"

cmtpath_pattern \
    macro genconfInstallDir "" \
       <project>_without_installarea&target-unix "$(<package>_root)/python" \
       <project>_without_installarea&target-winxp "$(<package>_root)\python" \
       <project>_with_installarea&target-unix "<path>/$(<project>_installarea_prefix)$(shared_install_subdir)/python"\
       <project>_with_installarea&target-winxp '"<path>\$(<project>_installarea_prefix)$(shared_install_subdir)\python"'

make_fragment genconfig -header=genconfig_header

macro merge_genconfDb_cmd "python $(GaudiPolicy_root)/scripts/merge_files.py"
make_fragment merge_genconfDb -header=merge_genconfDb_header

## genconf configuration defaults
macro genconfig_configurableModuleName "GaudiKernel.Proxy"
macro genconfig_configurableDefaultName "Configurable.DefaultName"
macro genconfig_configurableAlgorithm "ConfigurableAlgorithm"
macro genconfig_configurableAlgTool "ConfigurableAlgTool"
macro genconfig_configurableAuditor "ConfigurableAuditor"
macro genconfig_configurableService "ConfigurableService"

## add pattern and macro for library preloading for genconf

macro genconfig_preload ""

pattern genconfig_add_preload \
   macro_append genconfig_preload "--load-library=<library> " ;

# this pattern creates the helper library

pattern genconf_helper_lib \
   library <package>GenConfHelperLib <src> ; \
   macro <package>_genconfig_preload_lib "$(<package>_root)/$(tag)/$(library_prefix)<package>GenConfHelperLib.$(shlibsuffix)" \
              target-winxp             "$(<package>_root)\$(tag)\$(library_prefix)<package>GenConfHelperLib.$(shlibsuffix)" ; \
   macro <package>GenConfHelperLib_shlibflags "$(<package>GenConfHelperLib_use_linkopts)" ; \
   apply_pattern linker_library library=<package>GenConfHelperLib ; \
   macro_remove <package>_linkopts " -l<package>GenConfHelperLib" \
              target-winxp                " <package>GenConfHelperLib.lib" ; \
   macro_append <package>Conf_dependencies " <package>GenConfHelperLib "

# this pattern uses the helper library. the "pkg" argument is the package
# containing the helper lib

pattern use_genconf_helper_lib \
   private ; \
   apply_pattern genconfig_add_preload library=$(<pkg>_genconfig_preload_lib) ; \
   end_private


# this use statement is here only to get the building order right
# ie: tell CMT that genconf needs (at runtime) the GaudiSvc component
#     library to be available for loading.
macro use_GaudiSvc "GaudiSvc * -no_auto_imports" \
        no_genconf "" \
        do_genconf "GaudiSvc * -no_auto_imports" \
        ATLAS "GaudiSvc * -no_auto_imports"

# if one wants to modify this pattern, the correction has to be made also
# in the GaudiSvc requirements file since it is using directly
# generate_configurables_internal to avoid infinite recursion
# with "use GaudiSvc"
pattern generate_configurables \
  private ; \
   use $(use_GaudiSvc) ;\
   apply_pattern generate_configurables_internal library=<library> group=<group> ; \
  end_private

pattern generate_configurables_internal \
  macro <package>_genConf_python "" \
       <project>_without_installarea&target-unix "$(genconfInstallDir)" \
       <project>_without_installarea&target-winxp "$(genconfInstallDir)" ; \
  path_remove  PYTHONPATH ${<package>_genConf_python} ; \
  path_prepend PYTHONPATH ${<package>_genConf_python} ; \
  private ; \
   macro run_genconfig_cmd "do_real_genconfig" \
         no_genconf        "do_null_genconfig" \
         do_genconf        "do_real_genconfig" \
         ATLAS             "do_real_genconfig" ; \
   apply_pattern $(run_genconfig_cmd) library=<library> group=<group> ; \
  end_private

pattern do_real_genconfig \
  document genconfig <library>Conf -s=../$(tag) -group=<group> \
           outdir=$(<package>_root)$(genconfDir)<package> \
           library=<library> \
	   library_preload=$(genconfig_preload) \
           conf_destdir=$(genconfInstallDir) \
           confModuleName=$(genconfig_configurableModuleName) \
           confDefaultName=$(genconfig_configurableDefaultName) \
           confAlgorithm=$(genconfig_configurableAlgorithm) \
           confAlgTool=$(genconfig_configurableAlgTool) \
           confAuditor=$(genconfig_configurableAuditor) \
           confService=$(genconfig_configurableService) \
           $(library_prefix)<library>.$(shlibsuffix) ; \
  macro_append <library>Conf_dependencies " <library> " ; \
  apply_pattern install_python_init package=<package> group=<group> ; \
  macro_append <group><package>_python_init_dependencies " <library>Conf " ; \
  private ; \
    macro merge_genconfDb_tag "--do-merge"   \
	  do_merge_genconfDb  "--do-merge"   \
	  no_merge_genconfDb  "--un-merge" ; \
    document merge_genconfDb <library>ConfDbMerge -group=<group> \
	     inDir=$(<package>_root)$(genconfDir)<package> \
             library=<library> \
	     merge_genconfDb_switch=$(merge_genconfDb_tag)  \
	     $(bin)$(library_prefix)<library>.$(shlibsuffix) ; \
    macro_append <library>ConfDbMerge_dependencies " <library>Conf " ; \
    macro_append zip_<group><package>_python_modules_dependencies " <library>ConfDbMerge " ; \
  end_private


pattern do_null_genconfig \
  private ; \
   macro dummy_for_<library>Conf "<library> <group>" ; \
  end_private

#-------------------------------------------------------------------
# end of genconf
#-------------------------------------------------------------------

#-------------------------------------------------------------------
# QMTest (Marco Clemencic)
#-------------------------------------------------------------------
# Allow to execute the qmtest actions on packages not applying the
# correct patterns (QMTest or QMTestSummarize)
action qmtest_run "echo This package does not provide QMTest-based tests"
action qmtest_summarize "echo You need to apply the pattern QMTestSummarize to use this action"
action TestPackage "echo This package does not provide QMTest-based tests"
action TestProject "echo You need to apply the pattern QMTestSummarize to use this action"

# Pattern used internally by the 2 main patterns
pattern QMTestCommon \
  private ; \
    macro use_qmtest "" QMTest "QMtest * LCG_Interfaces -no_auto_imports" ; \
    use $(use_qmtest) ; \
    macro use_pytools "" QMTest "pytools * LCG_Interfaces -no_auto_imports" ; \
    use $(use_pytools) ; \
    set QMTESTRESULTS "" QMTest "../../$(tag)/results.qmr" ; \
  end_private

# Pattern defining the structure for QMTest-based tests.
#
# The user must:
#  1 - apply the pattern QMTest (in the requirements file)
#  2 - provide the directory <package_root>/tests/qmtest with the xml files
#      describing the tests (files .qmt, examples can be found in GaudiKerenel
#      and GaudiExamples)
#  2b- (optional) provide a test suite (file .qms) with the same name of the
#      package (all lowercase) to specify which tests to run (if not all)
#  3 - make CMTEXTRATAGS=QMTest tests
#  4 - cmt -tag_add=QMTest qmtest_run
#
# Note: Instead of adding CMTEXTRATAGS= or -tag_add=, one can define the
#       environment variable CMTEXTRATAGS.
#
# Suggestion: add a .cvsignore file in <package_root>/tests/qmtest containing
#             the 2 lines:
#                 QMTest
#                 results.qmr
#             This will avoid auto-generated files to go into CVS.
#
pattern QMTest \
  apply_pattern QMTestCommon ; \
  private ; \
    macro qmtest_local_dir "../tests/qmtest" target-winxp "..\tests\qmtest" ; \
    set QMTESTLOCALDIR "" QMTest "$(qmtest_local_dir)" ; \
    action qmtest_run "cmt -tag_add=QMTest run python $(GaudiPolicy_root)/scripts/run_qmtest.py $(package) $(cmt_args)" ; \
    macro_append qmtest_run_dependencies " tests " ; \
    action TestPackage "cmt qmtest_run $(cmt_args)" ; \
    action QMTestTestsDatabase "cmt qmtest_run --no-output --dry-run" ; \
    action QMTestGUI "cmt -tag_add=QMTest run 'cd $(qmtest_local_dir) ; qmtest gui'" ; \
  end_private

# Pattern allowing a package to generate a summary of the results run in the
# packages it depends on (for container packages like GaudiRelease)
pattern QMTestSummarize \
  apply_pattern QMTestCommon ; \
  private ; \
    macro qmtest_summarize_script "$(GaudiPolicy_root)/scripts/qmtest_summarize.py" ; \
    action qmtest_summarize "cmt -tag_add=QMTest run python $(qmtest_summarize_script) $(cmt_args)" ; \
    action TestProject "cmt br cmt TestPackage ; cmt qmtest_summarize" \
                 target-winxp "cmt br cmt TestPackage & cmt qmtest_summarize" ; \
  end_private

# Add the Gaudi specialized test extension to the QMTest path
path_append QMTEST_CLASS_PATH "" QMTest "$(GAUDIPOLICYROOT)/qmtest_classes"

# These three lines are needed to avoid that "make all_groups" triggers the
# actions it should not trigger.
macro_remove cmt_actions_constituents 'make'
macro_remove cmt_actions_constituents 'qmtest_run'
macro_remove cmt_actions_constituents 'qmtest_summarize'
macro_remove cmt_actions_constituents 'TestPackage'
macro_remove cmt_actions_constituents 'TestProject'
macro_remove cmt_actions_constituents 'QMTestTestsDatabase'
macro_remove cmt_actions_constituents 'QMTestGUI'

#-------------------------------------------------------------------
# Pattern to disable a package on ath given platform or combination of tags.
# To be used with something like:
#
#   apply_pattern disable_package_on platform=Darwin
#   apply_pattern disable_package_on platform=slc4-amd64&gcc41
#
# (Marco Clemencic)
#-------------------------------------------------------------------
pattern disable_package_on \
  private ; \
    macro_remove_regexp all_constituents "" \
                       <platform> ".*" ; \
	macro_remove_regexp <package>_stamps "" \
	                   <platform> ".*" ; \
  end_private


#-------------------------------------------------------------------
# Pattern defining a Gaudi application.
# It sets two environment variables that are checked by gaudirun.py to set
# the properties AppName and AppVersion of ApplicationMgr.
#
# Usage:
#
#    apply_pattern GaudiApp
#
# (Marco Clemencic)
#-------------------------------------------------------------------
pattern GaudiApp \
    use Gaudi * ; \
    set GAUDIAPPNAME "<package>" ; \
    set GAUDIAPPVERSION "<version>"


#-------------------------------------------------------------------
# Generic pattern to call a command.
# It is driven by macros.
# E.g:
#
#   macro MyCommandTarget_output  "output.file"
#   macro MyCommandTarget_deps    "input.file"
#   macro MyCommandTarget_command "python do_something.py -o $(MyCommandTarget_output) $(MyCommandTarget_deps)"
#
#   apply_pattern CallCommand target=MyCommandTarget
#
# (Marco Clemencic)
#-------------------------------------------------------------------
make_fragment call_command -header=call_command_header
pattern CallCommand \
   document call_command <target> -group=<group> name="<target>"

# Empty pattern to be able to have a conditional apply of "CallCommand"
pattern NullCommand \
    private ; \
        macro dummy_for_NullCommand "<target> <group>" ; \
    end_private

#-------------------------------------------------------------------
# Pattern to create a <package>Version.h header file in the InstallArea/include.
# Usage:
#
#   apply_pattern ProjectVersionHeader proj=Gaudi
#
# (Marco Clemencic)
#-------------------------------------------------------------------
pattern ProjectVersionHeader \
	private ; \
	macro ProjectVersionHeader_output "$(CMTINSTALLAREA)$(shared_install_subdir)/include/<project>_VERSION.h" ; \
	macro ProjectVersionHeader_deps "../cmt/requirements" ; \
	macro ProjectVersionHeader_command "python $(GaudiPolicy_root)/scripts/createProjVersHeader.py <project> <version> $(ProjectVersionHeader_output)" \
	     <project>_without_installarea "" ; \
	apply_pattern CallCommand target=ProjectVersionHeader ; \
	end_private ; \
	set <project>VERS "<version>"

#-------------------------------------------------------------------
# Generic cmt template processing
# take "fichier.tmpl" as input and outputs "fichier" with all
# cmt macros expanded. E.g:
#
#  document template DoxyTemplate -s=../doc *.tmpl
#
#-------------------------------------------------------------------

make_fragment template -header=template_header -dependencies

#-------------------------------------------------------------------
# Path cleaner
#-------------------------------------------------------------------

macro strip_script "$(GAUDIPOLICYROOT)/scripts/StripPath" \
     no-strip-path "" \
      target-winxp "$(GAUDIPOLICYROOT)\scripts\StripPath"

cmtpath_pattern \
    setup_script $(strip_script) ;

#-------------------------------------------------------------------
# genconfuser (Marco Clemencic)
# Create a confDb.py file for ConfigurableUser specializations
#
#-------------------------------------------------------------------
macro GenConfUser_script "genconfuser.py" \
                   target-winxp "genconfuser.bat"
pattern real_genconfuser \
	private ; \
	macro <package>GenConfUser_output "$(<package>_root)$(genconfDir)<package>/<package>_user_confDb.py" \
	                            target-winxp "$(<package>_root)$(genconfDir)<package>\<package>_user_confDb.py" ; \
	macro <package>GenConfUser_python "$(<package>_root)/python" \
                                    target-winxp "$(<package>_root)\python" ; \
	macro <package>GenConfUser_deps "FORCE" ; \
	macro <package>GenConfUser_command "$(GenConfUser_script) --lockerpath $(GaudiPolicy_root)/scripts -r $(<package>GenConfUser_python) -o $(<package>GenConfUser_output) <package> $(<package>ConfUserModules)" ; \
	apply_pattern CallCommand target=<package>GenConfUser ; \
	document merge_genconfDb <package>ConfUserDbMerge -group=<group> \
		inDir=$(<package>_root)$(genconfDir)<package> \
		library=<package>_user \
		merge_genconfDb_switch="--do-merge" ; \
	macro_append <package>_python_init_dependencies " <package>GenConfUser " ; \
	macro_append <package>ConfUserDbMerge_dependencies " <package>GenConfUser <package>_python " ; \
	end_private

pattern fake_genconfuser

pattern genconfuser \
	private ; \
	macro do_genconfuser "real_genconfuser" \
	    skip_genconfuser "fake_genconfuser" ; \
	apply_pattern $(do_genconfuser) ; \
	end_private

#-------------------------------------------------------------------
# Pattern to flag a package as "container package".
# The container package must have the line:
#
#  apply_pattern container_package
#
# Global patterns that needs to behave differently in a container
# package can use the tag "containter-package" (private).
#-------------------------------------------------------------------
pattern container_package \
	private ; \
	apply_tag container-package ; \
	end_private

#-------------------------------------------------------------------
# Zip Python modules
#-------------------------------------------------------------------
pattern zip_python_modules \
	private ; \
	macro zip_<group><package>_python_modules_output "$(CMTINSTALLAREA)$(shared_install_subdir)/python.zip" ; \
	macro zip_<group><package>_python_modules_deps "FORCE" ; \
	macro zip_<group><package>_python_modules_command "python $(GaudiPolicy_root)/scripts/ZipPythonDir.py $(CMTINSTALLAREA)$(shared_install_subdir)/python" ; \
	macro zip_<group><package>_python_modules_pattern_applied "CallCommand" \
		no-pyzip&container-package "CallCommand" \
		no-pyzip "NullCommand" ; \
	apply_pattern $(zip_<group><package>_python_modules_pattern_applied) target=zip_<group><package>_python_modules group=<group> ; \
	end_private

pattern -global zip_python_modules_container_fallback \
	private ; \
	macro zip_python_modules_container_fallback_pattern "" \
		no-pyzip&container-package "zip_python_modules" ; \
	apply_pattern $(zip_python_modules_container_fallback_pattern) ; \
	end_private

#-------------------------------------------------------------------
# Doxygen business
#-------------------------------------------------------------------

make_fragment doxygen -header=doxygen_header -dependencies

pattern doxy_vers_set \
	set <external>VERS "$(<external>_config_version)"

apply_pattern doxy_vers_set external=POOL
apply_pattern doxy_vers_set external=COOL
apply_pattern doxy_vers_set external=CORAL
apply_pattern doxy_vers_set external=ROOT
apply_pattern doxy_vers_set external=Boost
apply_pattern doxy_vers_set external=uuid
apply_pattern doxy_vers_set external=GCCXML
apply_pattern doxy_vers_set external=AIDA
apply_pattern doxy_vers_set external=XercesC
apply_pattern doxy_vers_set external=GSL
apply_pattern doxy_vers_set external=Python
apply_pattern doxy_vers_set external=HepMC
apply_pattern doxy_vers_set external=QMtest
# This one is special
set LCGCMTVERS "$(LCG_config_version)"

# Base directory of doxygen documentation
set GAUDI_DOXY_HOME $(GAUDI_home)/GaudiRelease/doc

# pattern -global CppCheck \
#     action CppCheck "cppcheck --all --quiet $(includes) ../src || echo 'No Cpp files' "

#-------------------------------------------------------------------
# ATLAS specific stuff
#-------------------------------------------------------------------

# don't create zipped python files for ATLAS
tag ATLAS no-pyzip

macro_append pp_cppflags "" \
      ATLAS " -DATLAS_GAUDI_V21 "