Build/AtlasCMake/modules/FindGaudi.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: FindGaudi.cmake 734809 2016-04-08 10:37:12Z krasznaa $
-#
-# CMake script attempting to find a Gaudi installation that we can build
-# the offline code against. Without making any use of the CMake code
-# bundled with the Gaudi installation.
-#
-# The module reads hints for the location of Gaudi from the following
-# variable(s):
-#
-#   GAUDI_ROOT      - The installation directory of the Gaudi version to use
-#
-# When invoked, the module sets up all environment variables to make it possible
-# to use ATLAS packages that depend on the various Gaudi packages, through an
-# atlas_depends_on_subdirs call.
-#
-
-# Only include this file once:
-if( GAUDI_FOUND )
-   return()
-endif()
-
-# Pull in Gaudi's location from the environment if necessary:
-if( NOT GAUDI_ROOT )
-   if( NOT "$ENV{GAUDI_ROOT}" STREQUAL "" )
-      set( GAUDI_ROOT $ENV{GAUDI_ROOT} )
-   else()
-      message( SEND_ERROR "GAUDI_ROOT not set" )
-      return()
-   endif()
-endif()
-
-# Try to find Gaudi in the specified directory:
-find_path( GAUDI_INSTALLAREA GaudiConfig.cmake PATHS ${GAUDI_ROOT} )
-set( Gaudi_ROOT_DIR ${GAUDI_INSTALLAREA} )
-find_path( GAUDI_INCLUDE_DIR GAUDI_VERSION.h
-   PATH_SUFFIXES include PATHS ${GAUDI_ROOT} )
-set( GAUDI_INCLUDE_DIRS ${GAUDI_INCLUDE_DIR} )
-set( GAUDI_LIBRARY_DIR ${GAUDI_INSTALLAREA}/lib )
-set( GAUDI_LIBRARY_DIRS ${GAUDI_LIBRARY_DIR} )
-set( GAUDI_PYTHON_PATH ${GAUDI_INSTALLAREA}/python )
-
-# Additional environment settings:
-set( GAUDI_ENVIRONMENT
-   SET GAUDI_ROOT ${GAUDI_ROOT}
-   APPEND JOBOPTSEARCHPATH ${GAUDI_INSTALLAREA}/jobOptions
-   APPEND DATAPATH ${GAUDI_INSTALLAREA}/share )
-
-# Handle the usual parameters given to find_package(...) calls:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( Gaudi DEFAULT_MSG GAUDI_INSTALLAREA
-   GAUDI_INCLUDE_DIR )
-mark_as_advanced( GAUDI_FOUND GAUDI_INSTALLAREA Gaudi_ROOT_DIR GAUDI_INCLUDE_DIR
-   GAUDI_INCLUDE_DIRS )
-
-# If Gaudi was not found, finish here:
-if( NOT GAUDI_FOUND )
-   return()
-endif()
-
-# The used Gaudi libraries use Boost, ROOT, TBB and Python:
-find_package( Boost QUIET REQUIRED COMPONENTS filesystem thread system regex )
-find_package( ROOT QUIET REQUIRED COMPONENTS Core )
-find_package( TBB QUIET )
-find_package( PythonLibs QUIET REQUIRED )
-
-# Set up the package interface libraries that atlas_depends_on_subdirs
-# will be able to use:
-macro( _gaudi_setup_pkg_lib pkgName )
-   add_library( ${pkgName}Pkg INTERFACE IMPORTED )
-   set_target_properties( ${pkgName}Pkg PROPERTIES
-      INTERFACE_INCLUDE_DIRECTORIES "${GAUDI_INSTALLAREA}/include" )
-endmacro( _gaudi_setup_pkg_lib )
-_gaudi_setup_pkg_lib( GaudiAlg )
-_gaudi_setup_pkg_lib( GaudiAud )
-_gaudi_setup_pkg_lib( GaudiKernel )
-_gaudi_setup_pkg_lib( GaudiPython )
-_gaudi_setup_pkg_lib( GaudiPluginService )
-_gaudi_setup_pkg_lib( GaudiSvc )
-_gaudi_setup_pkg_lib( PartPropSvc )
-_gaudi_setup_pkg_lib( RootHistCnv )
-unset( _gaudi_setup_pkg_lib )
-
-# Set up the libraries that we link against in the ATLAS code:
-add_library( GaudiPluginService SHARED IMPORTED )
-set_property( TARGET GaudiPluginService PROPERTY IMPORTED_CONFIGURATIONS
-   RELEASE )
-set_target_properties( GaudiPluginService PROPERTIES
-   IMPORTED_LOCATION_RELEASE "${GAUDI_INSTALLAREA}/lib/libGaudiPluginService.so"
-   IMPORTED_SONAME_RELEASE "@rpath/libGaudiPluginService.so"
-   INTERFACE_INCLUDE_DIRECTORIES "${GAUDI_INSTALLAREA}/include" )
-
-add_library( GaudiKernel SHARED IMPORTED )
-set_property( TARGET GaudiKernel PROPERTY IMPORTED_CONFIGURATIONS RELEASE )
-set_target_properties( GaudiKernel PROPERTIES
-   IMPORTED_LOCATION_RELEASE "${GAUDI_INSTALLAREA}/lib/libGaudiKernel.so"
-   IMPORTED_SONAME_RELEASE "@rpath/libGaudiKernel.so"
-   INTERFACE_LINK_LIBRARIES
-   "${Boost_LIBRARIES};${ROOT_LIBRARIES};${TBB_LIBRARIES};GaudiPluginService"
-   INTERFACE_INCLUDE_DIRECTORIES
-   "${GAUDI_INSTALLAREA}/include;${Boost_INCLUDE_DIRS};${TBB_INCLUDE_DIRS};${ROOT_INCLUDE_DIRS}"
-   COMPILE_FLAGS "${ROOT_CXX_FLAGS}" )
-
-# Import (the) executable(s) from Gaudi that we need during the build:
-add_executable( listcomponents IMPORTED )
-set_property( TARGET listcomponents PROPERTY IMPORTED_CONFIGURATIONS
-   RELEASE )
-set_target_properties( listcomponents PROPERTIES
-   IMPORTED_LOCATION         "${GAUDI_INSTALLAREA}/bin/listcomponents.exe"
-   IMPORTED_LOCATION_RELEASE "${GAUDI_INSTALLAREA}/bin/listcomponents.exe" )
-
-add_executable( xenv IMPORTED )
-set_property( TARGET xenv PROPERTY IMPORTED_CONFIGURATIONS
-   RELEASE )
-set_target_properties( xenv PROPERTIES
-   IMPORTED_LOCATION         "${GAUDI_INSTALLAREA}/scripts/xenv"
-   IMPORTED_LOCATION_RELEASE "${GAUDI_INSTALLAREA}/scripts/xenv" )
-
-add_executable( genconf IMPORTED )
-set_property( TARGET genconf PROPERTY IMPORTED_CONFIGURATIONS
-   RELEASE )
-set_target_properties( genconf PROPERTIES
-   IMPORTED_LOCATION         "${GAUDI_INSTALLAREA}/bin/genconf.exe"
-   IMPORTED_LOCATION_RELEASE "${GAUDI_INSTALLAREA}/bin/genconf.exe" )
-
-# Set up the RPM dependency for Gaudi:
-if( GAUDI_VERSION )
-   set( version ${GAUDI_VERSION} )
-elseif( ENV{GAUDI_VERSION} )
-   set( version $ENV{GAUDI_VERSION} )
-else()
-   set( version "21.0.0" )
-endif()
-set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-   "GAUDI_${version}_${ATLAS_PLATFORM}" )
-unset( version )

Build/AtlasCMake/modules/FindGeant4.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: FindGeant4.cmake 744789 2016-05-04 12:17:00Z krasznaa $
-#
-# Locate Geant4.
-# Defines:
-#  - GEANT4_FOUND
-#  - GEANT4_INCLUDE_DIR
-#  - GEANT4_INCLUDE_DIRS
-#  - GEANT4_<component>_FOUND
-#  - GEANT4_<component>_LIBRARY
-#  - GEANT4_LIBRARIES
-#  - GEANT4_LIBRARY_DIRS
-#
-# Can be steered by GEANT4_HOME_DIR + GEANT4_VERSION.
-#
-
-# Geant 4 is installed in a quite particular way. So the atlas_external_module
-# helper code is of little use unfortunately. :-(
-
-# Find the include path to Geant:
-find_path( GEANT4_INCLUDE_DIR NAMES G4Version.hh
-   PATH_SUFFIXES share/${GEANT4_VERSION}/include include/Geant4
-   PATHS ${GEANT4_HOME_DIR} )
-mark_as_advanced( GEANT4_INCLUDE_DIR )
-set( GEANT4_INCLUDE_DIRS ${GEANT4_INCLUDE_DIR} )
-
-# Try to extract the version of the found G4 instance:
-if( GEANT4_INCLUDE_DIR )
-   file( READ "${GEANT4_INCLUDE_DIR}/G4Version.hh" _g4version_h
-      LIMIT 20000 )
-   set( _version_regex
-      ".*#define G4VERSION_TAG \".Name. ([^\"]*) .\".*" )
-   if( "${_g4version_h}" MATCHES ${_version_regex} )
-      set( G4_VERSION ${CMAKE_MATCH_1} CACHE INTERNAL
-         "Detected version of Geant4" )
-   else()
-      set( G4_VERSION "${GEANT4_VERSION}" CACHE INTERNAL
-         "Specified version of Geant4" )
-   endif()
-else()
-   set( G4_VERSION "${GEANT4_VERSION}" CACHE INTERNAL
-      "Specified version of Geant4" )
-endif()
-
-# Select which libraries to use:
-list( APPEND Geant4_FIND_COMPONENTS
-   G4global G4event G4track G4particles G4tracking G4geometry G4digits_hits
-   G4graphics_reps G4intercoms G4materials G4run G4Tree G4visHepRep
-   G4readout G4processes G4physicslists G4interfaces G4vis_management G4modeling
-   G4persistency )
-list( REMOVE_DUPLICATES Geant4_FIND_COMPONENTS )
-
-# Find all the libraries:
-set( GEANT4_LIBRARIES )
-set( GEANT4_LIBRARY_DIRS )
-foreach( _component ${Geant4_FIND_COMPONENTS} )
-   # Search for the requested library:
-   find_library( GEANT4_${_component}_LIBRARY NAMES ${_component}
-      PATH_SUFFIXES specific/${ATLAS_PLATFORM}/${GEANT4_VERSION}/lib/Linux-g++
-                    lib
-      PATHS ${GEANT4_HOME_DIR} )
-   # Deal with the search results:
-   if( GEANT4_${_component}_LIBRARY )
-      set( GEANT4_${_component}_FOUND TRUE )
-      list( APPEND GEANT4_FOUND_COMPONENTS ${_component} )
-      list( APPEND GEANT4_LIBRARIES ${GEANT4_${_component}_LIBRARY} )
-      get_filename_component( _libdir ${GEANT4_${_component}_LIBRARY} PATH )
-      list( APPEND GEANT4_LIBRARY_DIRS ${_libdir} )
-      unset( _libdir )
-   else()
-      set( GEANT4_${_component}_FOUND FALSE )
-   endif()
-   # Mark the component location as an advanced property:
-   mark_as_advanced( GEANT4_${_component}_LIBRARY
-      GEANT4_${_component}_FOUND )
-endforeach()
-if( GEANT4_LIBRARY_DIRS )
-   list( REMOVE_DUPLICATES GEANT4_LIBRARY_DIRS )
-   list( GET GEANT4_LIBRARY_DIRS 0 GEANT4_LIBRARY_DIR )
-endif()
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( Geant4 REQUIRED_VARS GEANT4_INCLUDE_DIR
-   GEANT4_LIBRARIES VERSION_VAR G4_VERSION )
-mark_as_advanced( GEANT4_FOUND )
-
-# Look for the geant4-config script:
-find_file( _g4_config NAMES geant4-config
-   PATH_SUFFIXES specific/${ATLAS_PLATFORM}/${GEANT4_VERSION}/bin
-   bin
-   PATHS ${GEANT4_HOME_DIR} )
-mark_as_advanced( _g4_config )
-if( _g4_config )
-   # Not finding it is not a problem. We just get extra information
-   # out of it when we find it. If we found it, ask it for all the
-   # compiler flags needed to use the G4 headers:
-   execute_process( COMMAND ${_g4_config} --cflags
-      TIMEOUT 30
-      OUTPUT_VARIABLE _cflags )
-   # Filter out just the macro definitions from it:
-   string( REGEX MATCHALL "-D[^ ]+"
-      _definitions "${_cflags}" )
-   # And now apply these:
-   if( NOT "${_definitions}" STREQUAL "" )
-      add_definitions( ${_definitions} )
-      set( GEANT4_DEFINITIONS ${_definitions} )
-   endif()
-   # Now clean up:
-   unset( _cflags )
-   unset( _definitions )
-endif()
-unset( _g4_config )
-
-# If Geant4 was found, set up some environment variables for it:
-if( GEANT4_FOUND )
-
-   # Default location of the data files. To be overridden by AtlasSetup:
-   set( _g4home "/afs/cern.ch/atlas/offline/external/geant4/releases" )
-   # Main directory of the headers/libraries:
-   get_filename_component( _helper "${GEANT4_INCLUDE_DIR}" PATH )
-   get_filename_component( _geant4 "${_helper}" PATH )
-   # Location of the data files:
-   set( _g4data "\${G4PATH}/share/\${G4VERS}/data" )
-   # The G4 platform/system:
-   if( APPLE )
-      set( _g4system "Darwin-g++" )
-   else()
-      set( _g4system "Linux-g++" )
-   endif()
-
-   # Set the environment:
-   set( GEANT4_ENVIRONMENT
-      SET G4VERS "${G4_VERSION}"
-      SET G4PATH "${_g4home}"
-      SET GEANT4 "${_geant4}"
-      SET Geant4_data "${_g4data}"
-      SET G4INSTALL "${_geant4}"
-      SET G4INCLUDE "${GEANT4_INCLUDE_DIR}"
-      SET G4LIB "${GEANT4_LIBRARY_DIR}"
-      SET G4SYSTEM "${_g4system}"
-      SET G4LEVELGAMMADATA "${_g4data}/PhotonEvaporation"
-      SET G4NEUTRONHPDATA  "${_g4data}/G4NDL"
-      SET G4LEDATA         "${_g4data}/G4EMLOW"
-      SET G4NEUTRONXSDATA  "${_g4data}/G4NEUTRONXS"
-      SET G4SAIDXSDATA     "${_g4data}/G4SAIDDATA" )
-
-   # Set up a dependency on the G4 data RPM:
-   set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-      "ATLAS_Geant4Data_${G4_VERSION}" )
-
-   # Clean up:
-   unset( _g4system )
-   unset( _geant4 )
-   unset( _g4data )
-   unset( _helper )
-   unset( _g4home )
-
-endif()

Build/AtlasCMake/modules/FindJavaSDK.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: FindJavaSDK.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# - Locate JavaSDK
-# Defines:
-#
-#  JAVASDK_FOUND
-#  JAVASDK_INCLUDE_DIR
-#  JAVASDK_INCLUDE_DIRS (not cached)
-#  JAVASDK_LIBRARIES
-#
-# Can be steered using JAVASDK_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME JavaSDK
-   INCLUDE_SUFFIXES include INCLUDE_NAMES jni.h )
-if( JAVASDK_INCLUDE_DIR )
-   list( APPEND JAVASDK_INCLUDE_DIRS ${JAVASDK_INCLUDE_DIR}/linux )
-endif()
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( JavaSDK DEFAULT_MSG JAVASDK_INCLUDE_DIR )
-mark_as_advanced( JAVASDK_FOUND JAVASDK_INCLUDE_DIR JAVASDK_INCLUDE_DIRS )

Build/AtlasCMake/modules/FindShowerDeconstruction.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: FindShowerDeconstruction.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# - Locate the SHOWERDECONSTRUCTION External
-# Defines:
-#
-#  SHOWERDECONSTRUCTION_FOUND
-#  SHOWERDECONSTRUCTION_INCLUDE_DIR
-#  SHOWERDECONSTRUCTION_INCLUDE_DIRS
-#  SHOWERDECONSTRUCTION_<component>_FOUND
-#  SHOWERDECONSTRUCTION_<component>_LIBRARY
-#  SHOWERDECONSTRUCTION_LIBRARIES
-#  SHOWERDECONSTRUCTION_LIBRARY_DIRS
-#
-# Can be steered by SHOWERDECONSTRUCTION_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME ShowerDeconstruction
-   INCLUDE_SUFFIXES include INCLUDE_NAMES Deconstruct.h
-   LIBRARY_SUFFIXES lib COMPULSORY_COMPONENTS Deconstruction )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( ShowerDeconstruction DEFAULT_MSG
-   SHOWERDECONSTRUCTION_INCLUDE_DIR SHOWERDECONSTRUCTION_LIBRARIES )
-mark_as_advanced( SHOWERDECONSTRUCTION_FOUND SHOWERDECONSTRUCTION_INCLUDE_DIR
-   SHOWERDECONSTRUCTION_INCLUDE_DIRS SHOWERDECONSTRUCTION_LIBRARIES
-   SHOWERDECONSTRUCTION_LIBRARY_DIRS )

Build/AtlasCMake/modules/FinddSFMT.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: FinddSFMT.cmake 725783 2016-02-23 17:15:28Z krasznaa $
-#
-# - Locate and install the dSFMT External
-# Defines:
-#
-#  DSFMT_FOUND
-#  DSFMT_INCLUDE_DIR
-#  DSFMT_INCLUDE_DIRS (not cached)
-#  DSFMT_LIBRARIES
-#
-# Can be steered using DSFMT_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME dSFMT
-   INCLUDE_SUFFIXES include INCLUDE_NAMES dSFMT.h
-   LIBRARY_SUFFIXES ${ATLAS_PLATFORM} lib
-   LIBRARY_PREFIX "dSFMT-"
-   COMPULSORY_COMPONENTS std sse2 )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( dSFMT DEFAULT_MSG DSFMT_INCLUDE_DIR
-   DSFMT_LIBRARIES )
-mark_as_advanced( DSFMT_FOUND DSFMT_INCLUDE_DIR DSFMT_INCLUDE_DIRS
-   DSFMT_LIBRARIES DSFMT_LIBRARY_DIRS )
-
-# Code using this external needs the following definition:
-add_definitions( -DDSFMT_MEXP=19937 )

Build/AtlasCMake/modules/Finddqm-common.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Finddqm-common.cmake 732986 2016-03-30 16:25:54Z krasznaa $
-#
-# Try to find DQM-COMMON
-# Defines:
-#  - DQM-COMMON_FOUND
-#  - DQM-COMMON_INCLUDE_DIR
-#  - DQM-COMMON_INCLUDE_DIRS
-#  - DQM-COMMON_<component>_FOUND
-#  - DQM-COMMON_<component>_LIBRARY
-#  - DQM-COMMON_LIBRARIES
-#  - DQM-COMMON_LIBRARY_DIRS
-#  - DQM-COMMON_PYTHON_PATH
-#  - DQM-COMMON_BINARY_PATH
-#
-# Can be steered by DQM-COMMON_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME dqm-common
-   INCLUDE_SUFFIXES installed/include INCLUDE_NAMES dqm_core/Algorithm.h
-   LIBRARY_SUFFIXES installed/${ATLAS_PLATFORM}/lib
-   COMPULSORY_COMPONENTS dqm_core_io dqm_core dqm_dummy_io dqm_dummy )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( dqm-common DEFAULT_MSG DQM-COMMON_INCLUDE_DIR
-   DQM-COMMON_LIBRARIES )
-mark_as_advanced( DQM-COMMON_FOUND DQM-COMMON_INCLUDE_DIR
-   DQM-COMMON_INCLUDE_DIRS DQM-COMMON_LIBRARIES DQM-COMMON_LIBRARY_DIRS )
-
-# Set DQM specific environment:
-if( DQM-COMMON_FOUND )
-   set( DQM-COMMON_PYTHON_PATH ${DQM-COMMON_ROOT}/installed/share/lib/python
-      ${DQM-COMMON_LIBRARY_DIRS} )
-   set( DQM-COMMON_BINARY_PATH
-      ${DQM-COMMON_ROOT}/installed/${ATLAS_PLATFORM}/bin
-      ${DQM-COMMON_ROOT}/installed/share/bin )
-endif()
-
-# Add the RPM dependencies:
-if( DQM-COMMON_FOUND )
-   # Set up a dependency on the main dqm-common RPM package:
-   set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-      "dqm-common-${DQM-COMMON_VERSION}_DQMCRelease_${ATLAS_PLATFORM}" )
-
-#   foreach( comp ${dqm-common_FIND_COMPONENTS} )
-#      if( DQM-COMMON_${comp}_FOUND )
-#         set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-#            "dqm-common-${DQM-COMMON_VERSION}_${comp}_${ATLAS_PLATFORM}" )
-#      endif()
-#   endforeach()
-endif()

Build/AtlasCMake/modules/Findgdb.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findgdb.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# Defines:
-#
-#  GDB_FOUND
-#  GDB_INCLUDE_DIR
-#  GDB_INCLUDE_DIRS
-#  GDB_<component>_FOUND
-#  GDB_<component>_LIBRARY
-#  GDB_LIBRARIES
-#  GDB_LIBRARY_DIRS
-#
-# Can be steered by GDB_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME gdb
-   INCLUDE_SUFFIXES include INCLUDE_NAMES bfd.h
-   LIBRARY_SUFFIXES lib lib64
-   DEFAULT_COMPONENTS bfd iberty
-   EXTRA_OPTIONS NO_SYSTEM_ENVIRONMENT_PATH NO_CMAKE_SYSTEM_PATH )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( gdb DEFAULT_MSG GDB_INCLUDE_DIRS
-   GDB_LIBRARIES )
-mark_as_advanced( GDB_FOUND GDB_INCLUDE_DIR GDB_INCLUDE_DIRS
-   GDB_LIBRARIES GDB_LIBRARY_DIRS )

Build/AtlasCMake/modules/Findgperftools.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findgperftools.cmake 732185 2016-03-24 13:58:59Z krasznaa $
-#
-# Defines:
-#
-#  GPERFTOOLS_FOUND
-#  GPERFTOOLS_INCLUDE_DIR
-#  GPERFTOOLS_LIBRARIES
-#
-# Can be steered using GPERFTOOLS_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME gperftools
-   INCLUDE_SUFFIXES include INCLUDE_NAMES gperftools/tcmalloc.h
-   LIBRARY_SUFFIXES lib
-   DEFAULT_COMPONENTS tcmalloc )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( gperftools DEFAULT_MSG
-   GPERFTOOLS_INCLUDE_DIRS GPERFTOOLS_LIBRARIES )
-mark_as_advanced( GPERFTOOLS_FOUND GPERFTOOLS_INCLUDE_DIR
-   GPERFTOOLS_INCLUDE_DIRS GPERFTOOLS_LIBRARIES GPERFTOOLS_LIBRARY_DIRS )

Build/AtlasCMake/modules/Findtdaq-common.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findtdaq-common.cmake 732986 2016-03-30 16:25:54Z krasznaa $
-#
-# Try to find TDAQ-COMMON.
-# Defines:
-#  - TDAQ-COMMON_FOUND
-#  - TDAQ-COMMON_INCLUDE_DIR
-#  - TDAQ-COMMON_INCLUDE_DIRS
-#  - TDAQ-COMMON_<component>_FOUND
-#  - TDAQ-COMMON_<component>_LIBRARY
-#  - TDAQ-COMMON_LIBRARIES
-#  - TDAQ-COMMON_LIBRARY_DIRS
-#  - TDAQ-COMMON_PYTHON_PATH
-#  - TDAQ-COMMON_BINARY_PATH
-#
-# Can be steered by TDAQ-COMMON_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME tdaq-common
-   INCLUDE_SUFFIXES installed/include INCLUDE_NAMES eformat/eformat.h
-   LIBRARY_SUFFIXES installed/${ATLAS_PLATFORM}/lib
-   COMPULSORY_COMPONENTS eformat ers )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( tdaq-common DEFAULT_MSG
-   TDAQ-COMMON_INCLUDE_DIR TDAQ-COMMON_LIBRARIES )
-mark_as_advanced( TDAQ-COMMON_FOUND TDAQ-COMMON_INCLUDE_DIR
-   TDAQ-COMMON_INCLUDE_DIRS TDAQ-COMMON_LIBRARIES TDAQ-COMMON_LIBRARY_DIRS )
-
-# Set TDAQ specific environment:
-if( TDAQ-COMMON_FOUND )
-   set( TDAQ-COMMON_PYTHON_PATH ${TDAQ-COMMON_ROOT}/installed/share/lib/python
-      ${TDAQ-COMMON_LIBRARY_DIRS} )
-   set( TDAQ-COMMON_BINARY_PATH
-      ${TDAQ-COMMON_ROOT}/installed/${ATLAS_PLATFORM}/bin
-      ${TDAQ-COMMON_ROOT}/installed/share/bin )    
-endif()
-
-# Add the RPM dependencies:
-if( TDAQ-COMMON_FOUND )
-   # Set up a dependency on the main tdaq-common RPM package:
-   set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-      "tdaq-common-${TDAQ-COMMON_VERSION}_TDAQCRelease_${ATLAS_PLATFORM}" )
-
-#   foreach( comp ${tdaq-common_FIND_COMPONENTS} )
-#      if( TDAQ-COMMON_${comp}_FOUND )
-#         set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-#            "tdaq-common-${TDAQ-COMMON_VERSION}_${comp}_${ATLAS_PLATFORM}" )
-#      endif()
-#   endforeach()
-endif()

Build/AtlasCMake/modules/Findtdaq.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findtdaq.cmake 732986 2016-03-30 16:25:54Z krasznaa $
-#
-# Try to find TDAQ
-# Defines:
-#  - TDAQ_FOUND
-#  - TDAQ_INCLUDE_DIR
-#  - TDAQ_INCLUDE_DIRS
-#  - TDAQ_<component>_FOUND
-#  - TDAQ_<component>_LIBRARY
-#  - TDAQ_LIBRARIES
-#  - TDAQ_LIBRARY_DIRS
-#  - TDAQ_PYTHON_PATH
-#  - TDAQ_BINARY_PATH
-#  - TDAQ_DB_PATH
-#
-# Can be steered by TDAQ_ROOT.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME tdaq
-   INCLUDE_SUFFIXES installed/include INCLUDE_NAMES RunControl/RunControl.h
-   LIBRARY_SUFFIXES installed/${ATLAS_PLATFORM}/lib
-   COMPULSORY_COMPONENTS ipc )
-
-# Add the platform specific header directory, if the platform agnostic directory
-# was found:
-if( TDAQ_INCLUDE_DIRS )
-   list( APPEND TDAQ_INCLUDE_DIRS
-      ${TDAQ_ROOT}/installed/${ATLAS_PLATFORM}/include )
-endif()
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( tdaq DEFAULT_MSG TDAQ_INCLUDE_DIR
-   TDAQ_LIBRARIES )
-mark_as_advanced( TDAQ_FOUND TDAQ_INCLUDE_DIR TDAQ_INCLUDE_DIRS TDAQ_LIBRARIES
-   TDAQ_LIBRARY_DIRS )
-
-# Set TDAQ specific environment:
-if( TDAQ_FOUND )
-   set( TDAQ_PYTHON_PATH ${TDAQ_ROOT}/installed/share/lib/python
-      ${TDAQ_LIBRARY_DIRS} )
-   set( TDAQ_BINARY_PATH ${TDAQ_ROOT}/installed/${ATLAS_PLATFORM}/bin
-      ${TDAQ_ROOT}/installed/share/bin )
-   set( TDAQ_ENVIRONMENT
-      SET    TDAQ_DB_PATH ${TDAQ_ROOT}/installed/share/data
-      APPEND TDAQ_DB_PATH ${TDAQ_ROOT}/installed/databases )
-endif()
-
-# When using tdaq, some macro definitions are made in the tdaq headers,
-# and should not be set by the build system itself.
-remove_definitions( -DHAVE_BOOL -DHAVE_DYNAMIC_CAST -DHAVE_NAMESPACES )
-
-# Add the RPM dependencies:
-if( TDAQ_FOUND )
-   # Set up a dependency on the main tdaq RPM package:
-   set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-      "tdaq-${TDAQ_VERSION}_DAQRelease_${ATLAS_PLATFORM}" )
-
-#   foreach( comp ${tdaq_FIND_COMPONENTS} )
-#      if( TDAQ_${comp}_FOUND )
-#         set_property( GLOBAL APPEND PROPERTY ATLAS_EXTERNAL_RPMS
-#            "tdaq-${TDAQ_VERSION}_${comp}_${ATLAS_PLATFORM}" )
-#      endif()
-#   endforeach()
-endif()

Build/AtlasCMake/modules/Findxml.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findxml.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# Defines:
-#
-#  XML_FOUND
-#  XML_INCLUDE_DIR
-#  XML_LIBRARIES
-#
-
-# Find the package using CMake's built-in FindLibXml2.cmake module:
-if( xml_FIND_QUIETLY )
-   find_package( LibXml2 QUIET )
-else()
-   find_package( LibXml2 )
-endif()
-
-# Set the variables expected by the offline code:
-if( LIBXML2_FOUND )
-   set( XML_FOUND TRUE )
-   set( XML_INCLUDE_DIR ${LIBXML2_INCLUDE_DIR} )
-   set( XML_INCLUDE_DIRS ${XML_INCLUDE_DIR} )
-   set( XML_LIBRARIES ${LIBXML2_LIBRARIES} )
-   set( XML_DEFINITIONS ${LIBXML2_DEFINITIONS} )
-endif()

Build/AtlasCMake/modules/Findyampl.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: Findyampl.cmake 725956 2016-02-24 16:35:37Z krasznaa $
-#
-# Locate the yampl external package.
-#
-# Defines:
-#  YAMPL_FOUND
-#  YAMPL_INCLUDE_DIR
-#  YAMPL_INCLUDE_DIRS
-#  YAMPL_<component>_FOUND
-#  YAMPL_<component>_LIBRARY
-#  YAMPL_LIBRARIES
-#  YAMPL_LIBRARY_DIRS
-#
-# The user can set YAMPL_ROOT to guide the script.
-#
-
-# Include the helper code:
-include( AtlasInternals )
-
-# Declare the module:
-atlas_external_module( NAME yampl
-   INCLUDE_SUFFIXES include INCLUDE_NAMES yampl/Channel.h
-   LIBRARY_SUFFIXES lib
-   COMPULSORY_COMPONENTS yampl )
-
-# Handle the standard find_package arguments:
-include( FindPackageHandleStandardArgs )
-find_package_handle_standard_args( yampl DEFAULT_MSG YAMPL_INCLUDE_DIRS
-   YAMPL_LIBRARIES )
-mark_as_advanced( YAMPL_FOUND YAMPL_INCLUDE_DIR YAMPL_INCLUDE_DIRS
-   YAMPL_LIBRARIES YAMPL_LIBRARY_DIRS )

Build/AtlasCMake/modules/GaudiCPackSettings.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: GaudiCPackSettings.cmake 733606 2016-04-04 09:39:19Z krasznaa $
-#
-# This file is picked up by Gaudi, when it's built against AtlasExternals.
-# It configures how Gaudi should use CPack.
-#
-
-# Tell the user what's happening:
-message( STATUS "Configuring GAUDI to use the ATLAS CPack settings" )
-
-# Remember the project name:
-set( _projectName ${CMAKE_PROJECT_NAME} )
-# Remember the project version:
-set( _projectVersion ${CMAKE_PROJECT_VERSION} )
-
-# Set the GAUDI version according to NICOS, if the environment variables
-# are available:
-if( NOT "$ENV{NICOS_ATLAS_ALT_RELEASE}" STREQUAL "" AND
-      NOT "$ENV{NICOS_ATLAS_ALT_RELEASE}" STREQUAL "None" )
-   set( CMAKE_PROJECT_VERSION $ENV{NICOS_ATLAS_ALT_RELEASE} )
-elseif( NOT "$ENV{NICOS_ATLAS_RELEASE}" STREQUAL "" )
-   set( CMAKE_PROJECT_VERSION $ENV{NICOS_ATLAS_RELEASE} )
-endif()
-
-# Call the package GAUDI, and not Gaudi:
-set( CMAKE_PROJECT_NAME "GAUDI" )
-
-# Make the GAUDI package depend on the AtlasExternals one:
-set( ATLAS_BASE_PROJECTS AtlasExternals ${AtlasExternals_VERSION} )
-
-# Do the regular ATLAS CPack configuration:
-include( AtlasInternals )
-atlas_cpack_setup()
-
-# Clean up:
-set( CMAKE_PROJECT_VERSION ${_projectVersion} )
-unset( _projectVersion )
-set( CMAKE_PROJECT_NAME ${_projectName} )
-unset( _projectName )
-unset( ATLAS_BASE_PROJECTS )

Build/AtlasCMake/modules/scripts/atlas_build_run.sh.in

-#!/bin/bash
-#
-# $Id: atlas_build_run.sh.in 725450 2016-02-22 09:40:30Z krasznaa $
-#
-# This script is used during the build to set up a functional runtime
-# environment for running scripts/executables.
-#
-
-# Transmit errors:
-set -e
-
-# Set up the environment:
-source @CMAKE_BINARY_DIR@/@ATLAS_PLATFORM@/setup.sh || exit 1
-
-# Run the command:
-exec $* || exit 1

Build/AtlasCMake/modules/scripts/atlas_ctest.sh.in

-#!/bin/bash
-#
-# $Id: atlas_ctest.sh.in 725483 2016-02-22 12:38:45Z krasznaa $
-#
-# This is a custom wrapper around the ctest command, to enable us to
-# capure the full build log of the individual packages.
-
-# Propagate errors:
-set -e
-
-# Save the original command line arguments:
-CMD_LINE_ARGS=$*
-
-# Extract all the necessary properties from the command line for writing
-# a log file correctly.
-LOG_DIR=./
-BINARY_DIR=./
-BUILD_DIR=./
-while [[ $# > 1 ]]
-do
-    case $1 in
-        --log-dir)
-            LOG_DIR=$2
-            shift
-            ;;
-        --binary-dir)
-            BINARY_DIR=$2
-            shift
-            ;;
-        --build-dir)
-            BUILD_DIR=$2
-            shift
-            ;;
-        --)
-            shift
-            break
-            ;;
-        *)
-            ;;
-    esac
-    shift
-done
-
-# Figure out the package's name based on the binary and the build dirs:
-if [ ${BINARY_DIR} = ${BUILD_DIR} ];
-then
-    LOG_FILE=Project.log
-else
-    PKG_DIR=${BUILD_DIR:$((${#BINARY_DIR}+1))}
-    LOG_FILE=$(basename ${PKG_DIR}).log
-fi
-
-# Write the command line to the log file:
-echo "# CMake ---> $*" >> ${LOG_DIR}/${LOG_FILE}
-# Now call ctest with the same command line options, redirecting its output
-# to the specified log file. Note that the exit status of the actual command
-# is not in $? in the end. As that's populated by the exit status of the tee
-# command...
-@CMAKE_CTEST_COMMAND@ ${CMD_LINE_ARGS} 2>&1 | tee -a ${LOG_DIR}/${LOG_FILE}; \
-    test ${PIPESTATUS[0]} -eq 0

Build/AtlasCMake/modules/scripts/cpack_install.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: cpack_install.cmake 728702 2016-03-09 15:48:58Z krasznaa $
-
-# Atlas helper cpack script
-#set( CPACK_SET_DESTDIR FALSE )
-if( CPACK_SOURCE_PACKAGE_FILE_NAME )
-   message( STATUS
-      "Setting CPACK_INSTALLED_DIRECTORIES to "
-      "CPACK_SOURCE_INSTALLED_DIRECTORIES" )
-   set( CPACK_INSTALLED_DIRECTORIES "${CPACK_SOURCE_INSTALLED_DIRECTORIES}" )
-   set( CPACK_RPM_PACKAGE_ARCHITECTURE
-      "${CPACK_SOURCE_RPM_PACKAGE_ARCHITECTURE}" )
-   set( CPACK_RPM_PACKAGE_NAME "${CPACK_SOURCE_RPM_PACKAGE_NAME}" )
-endif()

Build/AtlasCMake/modules/scripts/cpack_install.sh.in

-#!/bin/bash
-#
-# $Id: cpack_install.sh.in 734111 2016-04-05 15:24:32Z krasznaa $
-#
-# Script used for installing a project for CPack. Hiding any build errors
-# from the package generator.
-#
-
-# Turn off error reporting:
-set +e
-
-# Make sure that the project is built. The DESTDIR setting is just to make sure
-# that some strange build steps don't interfere with the installation.
-#DESTDIR=/ make -k
-
-# Install the project:
-DESTDIR=${DESTDIR}/usr/@CMAKE_PROJECT_NAME@/@CPACK_PACKAGE_VERSION@ \
-    make -k install/fast
-
-# Remove the .dbg files from being packaged, in case we are in RelWithDebInfo
-# build mode:
-rm -f ${DESTDIR}/usr/@CMAKE_PROJECT_NAME@/@CPACK_PACKAGE_VERSION@/InstallArea/@ATLAS_PLATFORM@/bin/*.dbg
-rm -f ${DESTDIR}/usr/@CMAKE_PROJECT_NAME@/@CPACK_PACKAGE_VERSION@/InstallArea/@ATLAS_PLATFORM@/lib/*.dbg
-
-# Exit gracefully:
-exit 0

Build/AtlasCMake/modules/scripts/extractCTestBuild.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-# $Id: extractCTestBuild.py 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# This script is used by the nightly build CTest script to split a single
-# Build.xml file into multiple ones that can be used to upload build information
-# about the individual sub-projects (packages).
-#
-
-# Python import(s):
-import optparse
-import xml.dom.minidom
-
-## C/C++ style main function
-def main():
-
-    # Read the command line options:
-    parser = optparse.OptionParser( usage = "%prog [options]",
-                                    description = "Script used to extract the " \
-                                    "build results of a single subproject/" \
-                                    "package out of the full build log of a " \
-                                    "project." )
-    parser.add_option( "-i", "--input", dest = "input", action = "store",
-                       type = "string",
-                       help = "Name of the input Build.xml file" )
-    parser.add_option( "-o", "--output", dest = "output", action = "store",
-                       type = "string",
-                       help = "Name of the output Build.xml file" )
-    parser.add_option( "-l", "--label", dest = "label", action = "store",
-                       type = "string", default = "",
-                       help = "Label/subproject/package to extract" )
-    parser.add_option( "-n", "--no-label", dest = "no_label",
-                       action = "store_true",
-                       help = "Collect the warnings/errors with no labels" )
-    parser.add_option( "-v", "--verbose", dest = "verbose",
-                       action = "store_true", help = "Print verbose output" )
-    ( options, unknown ) = parser.parse_args()
-
-    # Check for errors:
-    if len( unknown ):
-        parser.error( "The following options were not recognised: %s" % \
-                      str( unknown ) )
-        return 1
-    if options.label != "" and options.no_label:
-        parser.error( "Can't use --label and --no-label at the same time" )
-        return 1
-
-    # Greet the user:
-    if options.verbose:
-        print( "CDash build log extractor" )
-        print( "  input  = %s" % options.input )
-        print( "  output = %s" % options.output )
-        if options.no_label:
-            print( "  no_label" )
-        else:
-            print( "  label  = %s" % options.label )
-            pass
-        pass
-
-    # Parse the input XML file:
-    inputXml = xml.dom.minidom.parse( options.input )
-    topElement = inputXml.documentElement
-
-    # Access the build node:
-    buildNode = topElement.getElementsByTagName( "Build" )[ 0 ]
-
-    # Add a subproject label to the file, if we're in that mode:
-    if not options.no_label:
-
-        # Add a Subproject node to it with the specified label:
-        subPNode = inputXml.createElement( "Subproject" )
-        topElement.insertBefore( subPNode, buildNode )
-        subPNode.setAttribute( "name", options.label )
-
-        # Add a Labels node to it with a single label, the one specified
-        # on the command line.
-        labelsNode = inputXml.createElement( "Labels" )
-        topElement.insertBefore( labelsNode, buildNode )
-        labelNode = inputXml.createElement( "Label" )
-        labelsNode.appendChild( labelNode )
-        label = inputXml.createTextNode( options.label )
-        labelNode.appendChild( label )
-        pass
-
-    # Loop over the failures, and remove the ones not associated to the
-    # specified label. Or all failures that have any label associated.
-    # Depending on what the user asked for...
-    failures = buildNode.getElementsByTagName( "Failure" )
-    if options.verbose:
-        print( "Total number of failures: %i" % len( failures ) )
-        pass
-    for failure in failures:
-        labels = failure.getElementsByTagName( "Labels" )
-        if options.no_label:
-            if len( labels ) == 1:
-                buildNode.removeChild( failure )
-                continue
-        else:
-            if len( labels ) != 1:
-                buildNode.removeChild( failure )
-                continue
-            label = labels[ 0 ].getElementsByTagName( "Label" )
-            if len( label ) != 1:
-                buildNode.removeChild( failure )
-                continue
-            if label[ 0 ].childNodes[ 0 ].data != options.label:
-                buildNode.removeChild( failure )
-                continue
-            pass
-        pass
-
-    # Tell the user what happened:
-    if options.verbose:
-        print( "Failures selected: %i" % \
-               len( buildNode.getElementsByTagName( "Failure" ) ) )
-        pass
-
-    # Write out the modified XML into the specified output file:
-    outputXml = open( options.output, "w" )
-    outputXml.write( inputXml.toxml( encoding = "UTF-8" ) )
-    outputXml.close()
-
-    # Return gracefully:
-    return 0
-
-# Execute the main function:
-if __name__ == "__main__":
-    import sys
-    sys.exit( main() )

Build/AtlasCMake/modules/scripts/extractCTestTest.py

-#!/usr/bin/env python
-
-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-#
-# $Id: extractCTestTest.py 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# This script is used by the nightly build CTest script to split a single
-# Test.xml file into multiple ones that can be used to upload test information
-# about the individual sub-projects (packages).
-#
-
-# Python import(s):
-import optparse
-import xml.dom.minidom
-
-## C/C++ style main function
-def main():
-
-    # Read the command line options:
-    parser = optparse.OptionParser( usage = "%prog [options]",
-                                    description = "Script used to extract the " \
-                                    "test results of a single subproject/" \
-                                    "package out of the full test log of a " \
-                                    "project." )
-    parser.add_option( "-i", "--input", dest = "input", action = "store",
-                       type = "string",
-                       help = "Name of the input Test.xml file" )
-    parser.add_option( "-o", "--output", dest = "output", action = "store",
-                       type = "string",
-                       help = "Name of the output Test.xml file" )
-    parser.add_option( "-l", "--label", dest = "label", action = "store",
-                       type = "string", default = "",
-                       help = "Label/subproject/package to extract" )
-    parser.add_option( "-v", "--verbose", dest = "verbose",
-                       action = "store_true", help = "Print verbose output" )
-    ( options, unknown ) = parser.parse_args()
-
-    # Check for errors:
-    if len( unknown ):
-        parser.error( "The following options were not recognised: %s" % \
-                      str( unknown ) )
-        return 1
-
-    # Greet the user:
-    if options.verbose:
-        print( "CDash test log extractor" )
-        print( "  input  = %s" % options.input )
-        print( "  output = %s" % options.output )
-        print( "  label  = %s" % options.label )
-        pass
-
-    # Parse the input XML file:
-    inputXml = xml.dom.minidom.parse( options.input )
-    topElement = inputXml.documentElement
-
-    # Access the testing node:
-    testingNode = topElement.getElementsByTagName( "Testing" )[ 0 ]
-
-    # Add a Subproject node to it with the specified label:
-    subPNode = inputXml.createElement( "Subproject" )
-    topElement.insertBefore( subPNode, testingNode )
-    subPNode.setAttribute( "name", options.label )
-
-    # Add a Labels node to it with a single label, the one specified
-    # on the command line.
-    labelsNode = inputXml.createElement( "Labels" )
-    topElement.insertBefore( labelsNode, testingNode )
-    labelNode = inputXml.createElement( "Label" )
-    labelsNode.appendChild( labelNode )
-    label = inputXml.createTextNode( options.label )
-    labelNode.appendChild( label )
-
-    # Loop over the results, and remove the ones not associated to the
-    # specified label. Or all results that don't have any label associated.
-    # Depending on what the user asked for...
-    tests = testingNode.getElementsByTagName( "Test" )
-    if options.verbose:
-        print( "Total number of tests: %i" % len( tests ) )
-        pass
-    for test in tests:
-        labels = test.getElementsByTagName( "Labels" )
-        if len( labels ) != 1:
-            # We found an element in TestList...
-            continue
-        label = labels[ 0 ].getElementsByTagName( "Label" )
-        if len( label ) != 1:
-            testingNode.removeChild( test )
-            continue
-        if label[ 0 ].childNodes[ 0 ].data != options.label:
-            testingNode.removeChild( test )
-            continue
-        pass
-
-    # Tell the user what happened:
-    if options.verbose:
-        print( "Tests selected: %i" % \
-               len( testingNode.getElementsByTagName( "Test" ) ) )
-        pass
-
-    # Write out the modified XML into the specified output file:
-    outputXml = open( options.output, "w" )
-    outputXml.write( inputXml.toxml( encoding = "UTF-8" ) )
-    outputXml.close()
-
-    # Return gracefully:
-    return 0
-
-# Execute the main function:
-if __name__ == "__main__":
-    import sys
-    sys.exit( main() )

Build/AtlasCMake/modules/scripts/mergeFiles.sh

-#!/bin/bash
-#
-# $Id: mergeFiles.sh 711151 2015-11-27 12:00:55Z krasznaa $
-#
-# Script used to merge text files during the build procedure.
-#
-# Usage: mergeFiles <output> <input1> [input2...]
-#
-
-# Propagate errors:
-set -e
-
-# Get the output file name:
-ofile=$1
-shift
-
-# Loop over the files that need to be merged:
-firstFile=1
-for ifile in $*; do
-    # Only consider files that really exist:
-    if [ -f ${ifile} ]; then
-        # Overwrite, or append the file:
-        if [ ${firstFile} = 1 ]; then
-            cat ${ifile} > ${ofile}
-        else
-            cat ${ifile} >> ${ofile}
-        fi
-        firstFile=0
-    fi
-done