Build/AtlasCMake/AtlasCMakeConfig-version.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: AtlasCMakeConfig-version.cmake 711151 2015-11-27 12:00:55Z krasznaa $
-
-# The version is just a dummy. Note that we can't actually use svn's
-# Revision keyword here... (As it's not in a format that CMake would
-# understand as a version.)
-set( PACKAGE_VERSION "1.0.0" )
-
-# Check whether the requested PACKAGE_FIND_VERSION is compatible with this
-# installed version:
-if( "${PACKAGE_VERSION}" VERSION_LESS "${PACKAGE_FIND_VERSION}" )
-   set( PACKAGE_VERSION_COMPATIBLE FALSE )
-else()
-   set( PACKAGE_VERSION_COMPATIBLE TRUE )
-   if( "${PACKAGE_VERSION}" VERSION_EQUAL "${PACKAGE_FIND_VERSION}" )
-      set( PACKAGE_VERSION_EXACT TRUE )
-   endif()
-endif()

Build/AtlasCMake/AtlasCMakeConfig.cmake

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-# $Id: AtlasCMakeConfig.cmake 746543 2016-05-12 11:31:22Z krasznaa $
-#
-# This file is used to make it possible to pull in the code of this package into
-# a top level CMake file using:
-#
-#   find_package( AtlasCMake )
-#
-# Then, to make CMake find this file correctly, one has to use something like
-# the following on the command line:
-#
-#   CMAKE_PREFIX_PATH=../source/AtlasCMake cmake ../source
-#
-# Or:
-#
-#   cmake -DAtlasCMake_DIR=../source/AtlasCMake ../source
-#
-# The meat of the code is in the other files of the package, this file just
-# provides the interface to the find_package(...) function.
-
-# Print a status message that the file was found:
-if( NOT AtlasCMake_FIND_QUIETLY )
-   message( STATUS "AtlasCMake found with version: $Revision: 746543 $" )
-endif()
-
-# Get the current directory:
-get_filename_component( _thisdir "${CMAKE_CURRENT_LIST_FILE}" PATH )
-if( NOT AtlasCMake_FIND_QUIETLY )
-   message( STATUS "Including ATLAS CMake code from directory: ${_thisdir}" )
-endif()
-set( ATLASCMAKE_MODULEDIR ${_thisdir}/modules CACHE STRING
-   "Directory holding the ATLAS CMake files" FORCE )
-
-# Add it to the CMake module path:
-list( INSERT CMAKE_MODULE_PATH 0 ${_thisdir}/modules )
-list( REMOVE_DUPLICATES CMAKE_MODULE_PATH )
-
-# Make sure that since this project is being included directly, the built
-# projects don't shadow the modules of this package with possibly older
-# versions of the files.
-set( ATLAS_DONT_PREPEND_PROJECT_MODULES TRUE
-   CACHE BOOL "Prevent built projects from prepending to CMAKE_MODULE_PATH" )
-
-# Install the helper script(s) from the package:
-install( PROGRAMS ${_thisdir}/scripts/acmake.py DESTINATION bin )
-install( DIRECTORY ${_thisdir}/cmt2cmake DESTINATION .
-   USE_SOURCE_PERMISSIONS
-   PATTERN ".*" EXCLUDE
-   PATTERN "*.pyc" EXCLUDE )
-
-# If CTEST_USE_LAUNCHERS is turned on, create a dummy log file already
-# during configuration, which NICOS can pick up, and conclude that the
-# package's "build" was successful.
-if( CTEST_USE_LAUNCHERS )
-   file( MAKE_DIRECTORY ${CMAKE_BINARY_DIR}/BuildLogs )
-   file( WRITE ${CMAKE_BINARY_DIR}/BuildLogs/AtlasCMake.log
-      "Dummy build log\n"
-      "AtlasCMake: Package build succeeded" )
-endif()
-
-# Include the AtlasFunctions file:
-include( AtlasFunctions )
-
-# For now include the Athena adaptor functions:
-include( AthenaFunctions )
-
-# Enable/Configure the use of CTest in the project:
-atlas_ctest_setup()
-
-# Environment variable(s) needed for the build:
-set( ATLASCMAKE_ENVIRONMENT
-   APPEND PATH \${${CMAKE_PROJECT_NAME}_DIR}/cmt2cmake
-   SET GFORTRAN_UNBUFFERED_ALL "y" )
-
-# If there's a version file available, declare the version of this package
-# to the project:
-if( EXISTS ${_thisdir}/version.cmake )
-   file( READ ${_thisdir}/version.cmake _version LIMIT 10000 )
-   set_property( GLOBAL APPEND PROPERTY ATLAS_SPECIAL_PACKAGES
-      "Build/AtlasCMake" "${_version}" )
-elseif( EXISTS ${_thisdir}/cmt/version.cmt )
-   file( READ ${_thisdir}/cmt/version.cmt _version LIMIT 10000 )
-   set_property( GLOBAL APPEND PROPERTY ATLAS_SPECIAL_PACKAGES
-      "Build/AtlasCMake" "${_version}" )
-endif()
-
-# Clean up:
-unset( _thisdir )

Build/AtlasCMake/cmt/README

-The only reason this package has a cmt/ subdirectory, and a requirements file
-in it, is to make it usable in TagCollector. Once the existence of a
-requirements file will no longer be necessary for our release management
-infrastructure, this subdirectory should be removed.

Build/AtlasCMake/cmt/requirements

-package AtlasCMake
-
-author Attila Krasznahorkay <Attila.Krasznahorkay@cern.ch>

Build/AtlasCMake/cmt2cmake/README.rst

-Instructions for the cmt2cmake.py tool
-======================================
-
-Introduction
-------------
-The script ``cmt2cmake.py`` is a tool that can convert the configuration of a
-CMT_ project based on Gaudi_ to the equivalent one for CMake.
-
-This tools have limitations: it cannot cover all the possible cases, so, in some
-(hopefully few) circumstances, there is the need for manual adaptation of the
-generated files.
-
-To be noted that ``cmt2cmake.py`` doesn't use CMT and, instead of analyzing what
-CMT_ would do, it parses the configuration files (``requirements``) to try to
-understand what the developer wanted to do. Because of this approach, it
-requires a cache with the information collected for the projects the one to be
-converted depends on.  This cache has to be in the same directory as the script
-and can be easily generated running the script on all the required projects.
-
-Usage
------
-The usage is simple: just go to the top directory of the project to be converted
-and call the script.
-
-For example, to process LHCb, one has to prepare the cache for the information
-of Gaudi::
-
-    $ python cmt2cmake.py --cache-only /path/to/Gaudi
-
-The next step is to translate LHCb::
-
-    $ python cmt2cmake.py --cache-only /path/to/LHCb
-    $ python cmt2cmake.py /path/to/LHCb
-
-The first call updates the cache so that it can be used for the
-interdependencies of the packages in LHCb.
-
-Configuration
--------------
-Some packages need special treatment. Few cases are supported:
-
-    - `ignored_packages`: packages that should not treated at all
-    - `data_packages`: known data packages, cannot be used in dependencies
-    - `needing_python`: packages that need to link against Python
-    - `no_pedantic`: packages that cannot compile of the -pedantic option is used
-    - `ignore_env`: special environment variables that should not be set in CMake
-
-The configuration required for the conversion of a project can be stored in a
-JSON file called `cmt2cmake.cfg` at the top level directory of the project.
-
-It must be noted that `ignored_packages` and `data_packages` require the full
-name of the package (hat+name) while the others use only the simple package name
-(without hat).
-
-Testing
--------
-This directory contains also the tests for ``cmt2cmake.py``, written for
-nosetests_. To run the tests it is enough to go to the directory containing
-``cmt2cmake.py`` and call the nosetests command::
-
-    $ cd /path/to/cmt2cmake
-    $ nosetests -v --with-doctest
-
-
-Note
-----
-The parsing of CMT ``requirements`` files is implemented using the module
-``pyparsing``_. To simplify the use of the script, a copy of it is available
-together with the script itself.
-
-
-.. _CMT: http://www.cmtsite.org
-.. _CMake: http://www.cmake.org
-.. _Gaudi: http://cern.ch/gaudi
-.. _pyparsing: http://pyparsing.wikispaces.com
-.. _nosetests: http://nose.readthedocs.org
-

Build/AtlasCMake/cmt2cmake/cmt2cmake.cfg

-{
-   "ignored_packages": [
-      "AtlasExternalsRelease", "DetCommonRelease", "AtlasCoreRelease",
-      "AtlasConditionsRelease", "AtlasEventRelease", "AtlasReconstructionRelease",
-      "AtlasTriggerRelease", "AtlasAnalysisRelease", "AtlasSimulationRelease",
-      "AtlasOfflineRelease", "AtlasHLTRelease", "DetCommonRunTime", "AtlasCoreRunTime",
-      "AtlasConditionsRunTime", "AtlasEventRunTime", "AtlasReconstructionRunTime",
-      "AtlasTriggerRunTime", "AtlasAnalysisRunTime", "AtlasSimulationRunTime",
-      "AtlasOfflineRunTime", "AtlasHLTRunTime", "DetCommonPolicy", "AtlasCommonPolicy",
-      "AtlasCxxPolicy", "AtlasFortranPolicy",  "AtlasPolicy", "External/ExternalPolicy",
-      "External/AtlasCompilers",  "LCG_Settings", "LCG_Configuration", "LCG_Platforms", 
-      "TDAQCPolicy/TDAQCPolicyExt", 
-      "Tools/RunTimeTester/testsuite/testsuites/linuxinteractive/TestProject",
-      "Tools/RunTimeTester/testsuite/testsuites/linuxinteractive/Control/AthenaExamples/AthExHelloWorld",
-      "graphics/VP1/VP1Qt", "graphics/VP1/VP1Qwt",
-      "Build/AtlasCMake", "Build/AtlasLCG"
-   ],
-   "data_packages": [],
-   "needing_python": [],
-   "no_pedantic": [],
-   "ignore_env": [ "EXPORT_ALL_SYMBOLS" ]
-}

Build/AtlasCMake/cmt2cmake/test_cmt_parser.py

-# Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-
-from cmt2cmake import makeParser
-from pyparsing import ParseException
-
-CMTParser = makeParser(set(["QMTest", "install_python_modules", "install_scripts",
-                            "install_more_includes", "god_headers", "god_dictionary",
-                            "PyQtResource", "PyQtUIC"])
-                       | set(['reflex_dictionary', 'component_library', 'linker_library',
-                              'copy_relax_rootmap']))
-def _test_package():
-    tokens = list(CMTParser.parseString('package Test'))
-    assert tokens == ['package', 'Test']
-
-def test_version():
-    tokens = list(CMTParser.parseString('version v1r2p3'))
-    assert tokens == ['version', 'v1r2p3']
-
-def test_library():
-    statement = 'library  GaudiKernelLib  *.cpp  -no_static  -import=Boost'
-    tokens = list(CMTParser.parseString(statement))
-    print tokens
-    assert tokens == ['library', 'GaudiKernelLib', '*.cpp', '-no_static', '-import=Boost']
-
-    statement = 'library  TestLib  test/lib/*.cpp  a_variable=some_value  -group=tests'
-    tokens = list(CMTParser.parseString(statement))
-    print tokens
-    assert tokens == ['library', 'TestLib', 'test/lib/*.cpp', 'a_variable=some_value', '-group=tests']
-
-def test_macro():
-    s = 'macro_append ROOT_linkopts "some" WIN32 "other"'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['macro_append', 'ROOT_linkopts', '"some"', 'WIN32', '"other"']
-
-    s = 'macro a_var "value"'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['macro', 'a_var', '"value"']
-
-    s = 'macro a_var'
-    try:
-        tokens = list(CMTParser.parseString(s))
-        assert False, 'parsing should have failed: %r' % s
-    except ParseException:
-        pass
-
-def test_apply_pattern():
-    s = 'apply_pattern component_library library=L0DU'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['apply_pattern', 'component_library', 'library=L0DU']
-
-def test_implicit_apply_pattern():
-    s = 'component_library library=L0DU'
-    tokens = list(CMTParser.parseString(s))
-    print tokens
-    assert tokens == ['apply_pattern', 'component_library', 'library=L0DU']