CMake checks

cmake_support/PROMOD3.cmake

@@ -83,14 +83,14 @@ macro(parse_argument_list PREFIX ARG_NAMES OPT_NAMES)
   foreach(_ARG ${ARGN})
     set(_LARG_NAMES ${ARG_NAMES})  
     list(FIND _LARG_NAMES ${_ARG} _IS_ARG_NAME)
-    if (_IS_ARG_NAME GREATER -1)
+    if(_IS_ARG_NAME GREATER -1)
       set(${PREFIX}_${_CURR_ARG_NAME} ${_CURR_ARG_LIST})
       set(_CURR_ARG_NAME "${_ARG}")
       set(_CURR_ARG_LIST)
     else()
     set(_LOPT_NAMES ${OPT_NAMES})  
       list(FIND _LOPT_NAMES ${_ARG} _IS_OPT_NAME)
-      if (_IS_OPT_NAME GREATER -1)
+      if(_IS_OPT_NAME GREATER -1)
         set(${PREFIX}_${_ARG} TRUE)
       else()
         list(APPEND _CURR_ARG_LIST "${_ARG}")
@@ -138,10 +138,10 @@ macro(parse_file_list FILELIST FILEMAP)
   map(CREATE ${FILEMAP})
   set(_CURRENT_LIST)
   foreach(_ITEM ${FILELIST})
-    if (_ITEM STREQUAL "IN_DIR")
+    if(_ITEM STREQUAL "IN_DIR")
       set(_EXPECT_IN_DIR TRUE)
     else()
-      if (_EXPECT_IN_DIR)
+      if(_EXPECT_IN_DIR)
         set(_EXPECT_IN_DIR FALSE)
         map(SET ${FILEMAP} ${_ITEM} ${_CURRENT_LIST})
         set(_CURRENT_LIST)
@@ -180,7 +180,7 @@ macro(module)
   if(ENABLE_STATIC AND _ARG_NO_STATIC)
     return()
   endif()
-  if (_ARG_HEADER_OUTPUT_DIR)
+  if(_ARG_HEADER_OUTPUT_DIR)
     set(_HEADER_OUTPUT_DIR ${_ARG_HEADER_OUTPUT_DIR})
   else()
     set(_HEADER_OUTPUT_DIR "${_ARG_PREFIX}/${_ARG_NAME}")
@@ -204,17 +204,17 @@ macro(module)
                                    COMMAND ${CMAKE_COMMAND} -E make_directory
                                            "${CMAKE_BINARY_DIR}/tests")
   endif()
-  if (_ARG_SOURCES)
+  if(_ARG_SOURCES)
     # when there is at least one source file, we build a library
     set(_ABS_SOURCE_NAMES)
     foreach(_SOURCE ${_ARG_SOURCES})
-      if (IS_ABSOLUTE ${_SOURCE})
+      if(IS_ABSOLUTE ${_SOURCE})
         list(APPEND _ABS_SOURCE_NAMES "${_SOURCE}")
       else()
         list(APPEND _ABS_SOURCE_NAMES "${CMAKE_CURRENT_SOURCE_DIR}/${_SOURCE}")
       endif()
     endforeach()
-    if (ENABLE_STATIC AND NOT _ARG_NO_STATIC)
+    if(ENABLE_STATIC AND NOT _ARG_NO_STATIC)
       add_library(${_LIB_NAME} STATIC ${_ABS_SOURCE_NAMES})
     else()
       add_library(${_LIB_NAME} SHARED ${_ABS_SOURCE_NAMES})
@@ -236,7 +236,7 @@ macro(module)
                           LIBRARY_OUTPUT_DIRECTORY ${LIB_STAGE_PATH}
                           ARCHIVE_OUTPUT_DIRECTORY ${LIB_STAGE_PATH}
                           RUNTIME_OUTPUT_DIRECTORY ${LIB_STAGE_PATH})
-    if (APPLE)
+    if(APPLE)
       set_target_properties(${_LIB_NAME} PROPERTIES
                             LINK_FLAGS "-Wl,-rpath,@loader_path"
                             INSTALL_NAME_DIR "@rpath")
@@ -258,7 +258,7 @@ macro(module)
         add_dependencies(${_LIB_NAME} ${_DEPENDENCY})
       endif()
     endforeach()
-    if (ENABLE_STATIC)
+    if(ENABLE_STATIC)
       target_link_libraries(${_LIB_NAME} ${STATIC_LIBRARIES})
     endif()
   else()
@@ -270,7 +270,7 @@ macro(module)
   #-----------------------------------------------------------------------------
   # stage headers  
   #-----------------------------------------------------------------------------
-  if (_ARG_HEADERS)
+  if(_ARG_HEADERS)
     stage_and_install_headers("${_ARG_HEADERS}" "${_HEADER_OUTPUT_DIR}"
                               "${_LIB_NAME}")
   endif()
@@ -311,24 +311,24 @@ endmacro(stage_and_install_headers)
 macro(executable)
   parse_argument_list(_ARG 
                       "NAME;SOURCES;LINK;DEPENDS_ON" "NO_RPATH;STATIC" ${ARGN})
-  if (NOT _ARG_NAME)
+  if(NOT _ARG_NAME)
     message(FATAL_ERROR "invalid use of executable(): a name must be provided")
   endif()
   add_executable(${_ARG_NAME} ${_ARG_SOURCES})
-  if (APPLE AND NOT _ARG_NO_RPATH AND NOT ENABLE_STATIC)
+  if(APPLE AND NOT _ARG_NO_RPATH AND NOT ENABLE_STATIC)
     set_target_properties(${_ARG_NAME} PROPERTIES
                           LINK_FLAGS "-Wl,-rpath,@loader_path/../lib/")
   endif()
-  if (_ARG_LINK)
+  if(_ARG_LINK)
     target_link_libraries(${_ARG_NAME} ${_ARG_LINK})
   endif()
   foreach(_DEP ${_ARG_DEPENDS_ON})
     target_link_libraries(${_ARG_NAME} ${_DEP})
   endforeach()
-  if (ENABLE_STATIC AND _ARG_STATIC)
+  if(ENABLE_STATIC AND _ARG_STATIC)
     target_link_libraries(${_ARG_NAME} ${STATIC_LIBRARIES})
-    if (UNIX AND NOT APPLE)
-      if (PROMOD3_GCC_45)    
+    if(UNIX AND NOT APPLE)
+      if(PROMOD3_GCC_45)
         set_target_properties(${_ARG_NAME}
                               PROPERTIES LINK_SEARCH_END_STATIC TRUE  
                               LINK_FLAGS
@@ -354,7 +354,7 @@ endmacro(executable)
 macro(executable_libexec)
   parse_argument_list(_ARG 
                       "NAME;SOURCES;LINK;DEPENDS_ON" "NO_RPATH;STATIC" ${ARGN})
-  if (NOT _ARG_NAME)
+  if(NOT _ARG_NAME)
     message(FATAL_ERROR "invalid use of executable(): a name must be provided")
   endif()   
   add_executable(${_ARG_NAME} ${_ARG_SOURCES})
@@ -367,19 +367,19 @@ macro(executable_libexec)
   set_target_properties(${_ARG_NAME}
                         PROPERTIES RUNTIME_OUTPUT_DIRECTORY_DEBUG
                        "${LIBEXEC_STAGE_PATH}")  
-  if (NOT _ARG_NO_RPATH AND NOT _ARG_STATIC)
-    if (APPLE)
+  if(NOT _ARG_NO_RPATH AND NOT _ARG_STATIC)
+    if(APPLE)
       set_target_properties(${_ARG_NAME} PROPERTIES
                             LINK_FLAGS "-Wl,-rpath,@loader_path/../../lib")
-    elseif (UNIX)
+    elseif(UNIX)
       set_target_properties(${_ARG_NAME} PROPERTIES INSTALL_RPATH
                                                      "$ORIGIN/../../${LIB_DIR}")
-    endif (APPLE)
-  endif (NOT _ARG_NO_RPATH AND NOT _ARG_STATIC)
-  if (_ARG_LINK)
+    endif(APPLE)
+  endif(NOT _ARG_NO_RPATH AND NOT _ARG_STATIC)
+  if(_ARG_LINK)
     target_link_libraries(${_ARG_NAME} ${_ARG_LINK})
   endif()
-  if (ENABLE_STATIC AND _ARG_STATIC)
+  if(ENABLE_STATIC AND _ARG_STATIC)
     target_link_libraries(${_ARG_NAME} ${STATIC_LIBRARIES})
     set_target_properties(${_ARG_NAME}
                           PROPERTIES LINK_SEARCH_END_STATIC TRUE)  
@@ -399,10 +399,10 @@ endmacro(executable_libexec)
 macro(substitute)
  parse_argument_list(_ARG 
                      "IN_FILE;OUT_FILE;DICT" "" ${ARGN})
-  if (NOT _ARG_IN_FILE)
+  if(NOT _ARG_IN_FILE)
     message(FATAL_ERROR "invalid use of substitute(): no IN_FILE given")
   endif()
-  if (NOT _ARG_OUT_FILE)
+  if(NOT _ARG_OUT_FILE)
     message(FATAL_ERROR "invalid use of substitute(): no OUT_FILE given")
   endif()
   set(_SUBST_DICT -DINPUT_FILE=${_ARG_IN_FILE} -DOUT_FILE=${_ARG_OUT_FILE})
@@ -423,15 +423,15 @@ macro(script)
   set(_ARG_OUTPUT_DIR bin)
   parse_argument_list(_ARG 
                       "NAME;INPUT;SUBSTITUTE;TARGET;OUTPUT_DIR" "" ${ARGN})
-  if (NOT _ARG_NAME)
+  if(NOT _ARG_NAME)
     message(FATAL_ERROR "invalid use of executable(): a name must be provided")
   endif()
   set(_INPUT ${_ARG_NAME})
-  if (_ARG_INPUT)
+  if(_ARG_INPUT)
     set(_INPUT ${_ARG_INPUT})
   endif()
-  if (_ARG_SUBSTITUTE)
-    if (NOT _ARG_INPUT)
+  if(_ARG_SUBSTITUTE)
+    if(NOT _ARG_INPUT)
       message(FATAL_ERROR "script() can only substitute when INPUT is present.")
     endif()
 
@@ -469,13 +469,13 @@ macro(pymod)
   parse_argument_list(_ARG 
                      "NAME;CPP;PY;LINK;OUTPUT_DIR;DEPENDS_ON"
                      "NEED_CONFIG_HEADER" ${ARGN})
-  if (NOT _ARG_NAME)
+  if(NOT _ARG_NAME)
     message(FATAL_ERROR "invalid use of pymod(): a name must be provided")
   endif()
-  if (ENABLE_STATIC)
+  if(ENABLE_STATIC)
     return()
   endif()
-  if (_ARG_OUTPUT_DIR)
+  if(_ARG_OUTPUT_DIR)
     set(PYMOD_DIR "${PYTHON_MODULE_PATH}/${_ARG_OUTPUT_DIR}")
   else()
     set(PYMOD_DIR
@@ -486,22 +486,22 @@ macro(pymod)
   #-----------------------------------------------------------------------------
   # compile and link C++ wrappers
   #-----------------------------------------------------------------------------
-  if (_ARG_CPP)
+  if(_ARG_CPP)
     add_library("_${_ARG_NAME}" MODULE ${_ARG_CPP})
     set_target_properties("_${_ARG_NAME}"
                           PROPERTIES ECHO_STRING
                           "Building Python Module ${_ARG_NAME}")
     set(_PARENT_NAME "${_ARG_PREFIX}_${_ARG_NAME}")
     get_target_property(_CUSTOM_CHECK "${_PARENT_NAME}" HEADER_ONLY)
-    if (NOT _CUSTOM_CHECK)
+    if(NOT _CUSTOM_CHECK)
       set(_PARENT_LIB_NAME "${_PARENT_NAME}")
     endif()
     target_link_libraries("_${_ARG_NAME}" ${_PARENT_LIB_NAME} 
                           ${PYTHON_LIBRARIES} ${BOOST_PYTHON_LIBRARIES})
     set_target_properties("_${_ARG_NAME}"
                          PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${PYMOD_STAGE_DIR})
-    if (NOT ENABLE_STATIC)
-      if (_USE_RPATH)
+    if(NOT ENABLE_STATIC)
+      if(_USE_RPATH)
         string(REGEX REPLACE "/[^/]*" "/.." inv_pymod_path "/${PYMOD_DIR}")
         set_target_properties("_${_ARG_NAME}"
                            PROPERTIES INSTALL_RPATH "$ORIGIN${inv_pymod_path}/")
@@ -510,16 +510,16 @@ macro(pymod)
                               PROPERTIES INSTALL_RPATH "")
       endif()
     endif()
-    if (APPLE)
+    if(APPLE)
       file(RELATIVE_PATH _REL_PATH "${PYMOD_STAGE_DIR}" "${LIB_STAGE_PATH}")
       set_target_properties("_${_ARG_NAME}" PROPERTIES
                             LINK_FLAGS "-Wl,-rpath,@loader_path/${_REL_PATH}"
                             INSTALL_NAME_DIR "@rpath")
     endif()                          
-    if (NOT WIN32)
+    if(NOT WIN32)
       set_target_properties("_${_ARG_NAME}"
                           PROPERTIES PREFIX "")
-    else ()
+    else()
       set_target_properties("_${_ARG_NAME}"
                           PROPERTIES PREFIX "../")
 
@@ -535,14 +535,14 @@ macro(pymod)
   #-----------------------------------------------------------------------------
   # compile python files
   #-----------------------------------------------------------------------------
-  if (_ARG_PY)
+  if(_ARG_PY)
     set(_PY_FILES)
     set(_EXPECT_IN_DIR FALSE)
     foreach(_PY_FILE ${_ARG_PY})
-      if (_PY_FILE STREQUAL "IN_DIR")
+      if(_PY_FILE STREQUAL "IN_DIR")
         set(_EXPECT_IN_DIR TRUE)
       else()
-        if (_EXPECT_IN_DIR)
+        if(_EXPECT_IN_DIR)
           set(_EXPECT_IN_DIR FALSE)
           set(_DIR ${_PY_FILE})
           set(_ABS_PY_FILES)
@@ -571,7 +571,7 @@ macro(pymod)
         endif()
       endif()
     endforeach()
-    if (_PY_FILES)
+    if(_PY_FILES)
       add_custom_target("${_ARG_NAME}_pymod" ALL)
       set(_ABS_PY_FILES)
       foreach(_PY ${_PY_FILES})
@@ -635,7 +635,7 @@ macro(promod3_unittest)
   set(_SOURCES ${_ARG_SOURCES})
   set(CPP_TESTS)
   set(PY_TESTS)
-  if (NOT _ARG_MODULE)
+  if(NOT _ARG_MODULE)
     message(FATAL_ERROR
             "invalid use of promod3_unittest(): module name missing")
   endif()
@@ -662,7 +662,7 @@ macro(promod3_unittest)
     endforeach()
   endif(_ARG_DATA)
     foreach(src ${_SOURCES})
-      if (${src} MATCHES "\\.py$")
+      if(${src} MATCHES "\\.py$")
         list(APPEND PY_TESTS "${src}")
       else()
         list(APPEND CPP_TESTS "${CMAKE_CURRENT_SOURCE_DIR}/${src}")
@@ -708,7 +708,7 @@ macro(promod3_unittest)
       add_dependencies(check_xml "${_test_name}_run_xml")
       add_dependencies(codetest "${_test_name}_run")
       
-      if (_ARG_LINK)
+      if(_ARG_LINK)
         target_link_libraries("${_test_name}" ${_ARG_LINK})
       endif()
 
@@ -760,7 +760,7 @@ endmacro(promod3_unittest)
 #-------------------------------------------------------------------------------
 macro(add_unit_test_data_target)
   parse_argument_list(_ARG "DAT" "" ${ARGN})
-  if (NOT _ARG_DAT)
+  if(NOT _ARG_DAT)
     message(FATAL_ERROR
             "invalid use of add_unit_test_data_target(): target missing")
   endif()
@@ -785,12 +785,12 @@ endmacro(add_unit_test_data_target)
 # make sure the previously detected Python interpreter has the given module
 #-------------------------------------------------------------------------------
 macro(promod3_find_python_module MODULE)
-  if (NOT PYTHON_MODULE_${MODULE})
+  if(NOT PYTHON_MODULE_${MODULE})
     message(STATUS "Searching for python module ${MODULE} for ${PYTHON_BINARY}")
     execute_process(COMMAND ${PYTHON_BINARY} -c "import ${MODULE}"
                     OUTPUT_QUIET ERROR_QUIET
                     RESULT_VARIABLE _IMPORT_ERROR)
-    if (_IMPORT_ERROR)
+    if(_IMPORT_ERROR)
       message(FATAL_ERROR
               "Could not find python module ${MODULE}. Please install it")
     else()
@@ -813,9 +813,9 @@ macro(promod3_match_boost_python_version)
   # optimized;<lib1>;debug;<lib2>
   set(_BOOST_PYTHON_LIBRARY ${Boost_PYTHON_LIBRARY})
   list(LENGTH _BOOST_PYTHON_LIBRARY _BP_LENGTH)
-  if (_BP_LENGTH GREATER 1)
+  if(_BP_LENGTH GREATER 1)
     list(FIND _BOOST_PYTHON_LIBRARY optimized _OPTIMIZED_INDEX)
-    if (_OPTIMIZED_INDEX EQUAL -1)
+    if(_OPTIMIZED_INDEX EQUAL -1)
       message(FATAL_ERROR 
               "Error while trying to get path of boost python library")
     endif()
@@ -872,18 +872,18 @@ macro(setup_stage)
   set(SHARED_DATA_PATH ${STAGE_DIR}/share/promod3  )
   set(ETC_STAGE_PATH ${STAGE_DIR}/etc )
 
-  if (UNIX AND NOT APPLE)
+  if(UNIX AND NOT APPLE)
     check_architecture()
   endif()
   set (ARCH ${CMAKE_NATIVE_ARCH})
-  if ("${ARCH}" MATCHES "64" AND NOT _UBUNTU_LAYOUT)
+  if("${ARCH}" MATCHES "64" AND NOT _UBUNTU_LAYOUT)
     set(LIB_DIR lib64  )
     set(LIB_STAGE_PATH "${STAGE_DIR}/lib64"  )
   else()
     set(LIB_DIR lib  )
     set(LIB_STAGE_PATH "${STAGE_DIR}/lib"  )
   endif()
-  if (_UBUNTU_LAYOUT)
+  if(_UBUNTU_LAYOUT)
     set(LIBEXEC_PATH ${LIB_DIR}/promod3/libexec  )
     set(LIBEXEC_STAGE_PATH ${LIB_STAGE_PATH}/promod3/libexec  )
   else()
@@ -913,10 +913,10 @@ endfunction(get_compiler_version)
 
 
 macro(setup_compiler_flags)
-  if (CMAKE_COMPILER_IS_GNUCXX)
+  if(CMAKE_COMPILER_IS_GNUCXX)
     get_compiler_version(_GCC_VERSION)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall" )
-    if (_GCC_VERSION MATCHES "44")
+    if(_GCC_VERSION MATCHES "44")
       # gcc 4.4. is very strict about aliasing rules. the shared_count
       # implementation that is used boost's shared_ptr violates these rules. To
       # silence the warnings and prevent miscompiles, enable
@@ -935,7 +935,7 @@ macro(setup_boost)
                COMPONENTS unit_test_framework REQUIRED)
   set(BOOST_UNIT_TEST_LIBRARIES ${Boost_LIBRARIES})
   set(Boost_LIBRARIES)
-  if (ENABLE_STATIC)
+  if(ENABLE_STATIC)
     set(Boost_USE_STATIC_LIBS ON)
   endif()
   find_package(Boost ${_BOOST_MIN_VERSION}
@@ -964,11 +964,11 @@ endmacro(setup_boost)
 #-------------------------------------------------------------------------------
 macro(add_doc_dependency)
   parse_argument_list(_ADD_ARG "NAME;DEP" "" ${ARGN})
-  if (NOT _ADD_ARG_NAME)
+  if(NOT _ADD_ARG_NAME)
     message(FATAL_ERROR
             "invalid use of add_doc_dependency(): module name missing")
   endif()
-  if (NOT _ADD_ARG_DEP)
+  if(NOT _ADD_ARG_DEP)
     message(FATAL_ERROR
             "invalid use of add_doc_dependency(): dependencies missing")
   endif()
@@ -998,10 +998,10 @@ endmacro(add_doc_dependency)
 #-------------------------------------------------------------------------------
 macro(add_doc_source)
   parse_argument_list(_ARG "NAME;RST" "" ${ARGN})
-  if (NOT _ARG_NAME)
+  if(NOT _ARG_NAME)
     message(FATAL_ERROR "invalid use of add_doc_source(): module name missing")
   endif()
-  if (NOT _ARG_RST)
+  if(NOT _ARG_RST)
     message(FATAL_ERROR "invalid use of add_doc_source(): sources missing")
   endif()
   if(DEFINED PM3_RST_${_ARG_NAME})
@@ -1027,7 +1027,7 @@ endmacro(add_doc_source)
 #-------------------------------------------------------------------------------
 macro(add_py_mod_src)
   parse_argument_list(_ARG_DOC "MOD" "" ${ARGN})
-  if (NOT _ARG_DOC_MOD)
+  if(NOT _ARG_DOC_MOD)
     message(FATAL_ERROR "invalid use of add_py_mod_src(): sources missing")
   endif()
   if(DEFINED PM3_PY_MS)
@@ -1057,7 +1057,7 @@ endmacro(add_py_mod_src)
 #-------------------------------------------------------------------------------
 macro(add_to_pymod_list)
   parse_argument_list(_ARG_DOC "MOD" "" ${ARGN})
-  if (NOT _ARG_DOC_MOD)
+  if(NOT _ARG_DOC_MOD)
     message(FATAL_ERROR "invalid use of add_to_pymod_list(): module missing")
   endif()
   if(DEFINED PM3_PYMODULES)
@@ -1087,7 +1087,7 @@ endmacro(add_to_pymod_list)
 #-------------------------------------------------------------------------------
 macro(add_changelog_to_doc)
   parse_argument_list(_ARG_CLOG "FILE" "" ${ARGN})
-  if (NOT _ARG_CLOG_FILE)
+  if(NOT _ARG_CLOG_FILE)
     message(FATAL_ERROR "invalid use of add_changelog_to_doc(): file missing")
   endif()
   set(PM3_DOC_CHANGELOG "${_ARG_CLOG_FILE}" CACHE INTERNAL "" FORCE)
@@ -1123,7 +1123,7 @@ macro(pm_action ACTION TARGET)
   # storing tool names for bash completion
   string(REGEX REPLACE "^pm-" "" stripped_action ${ACTION})
   if(DEFINED PM3_ACTION_NAMES)
-    if (${PM3_ACTION_NAMES} MATCHES "${stripped_action}")
+    if(${PM3_ACTION_NAMES} MATCHES "${stripped_action}")
       set(_ACTION_NAMES "${PM3_ACTION_NAMES}")
     else()
       if("${PM3_ACTION_NAMES}" STREQUAL "")
@@ -1156,7 +1156,7 @@ macro(add_module_data)
     message(FATAL_ERROR
             "invalid use of add_module_data(): a DATALIST must be provided")
   endif()
-  if (NOT _AMD_ARG_DATASUBDIR)
+  if(NOT _AMD_ARG_DATASUBDIR)
     set(_amd_datapath "${SHARED_DATA_PATH}")
     set(_amd_datadest "share/promod3/")
   else()
@@ -1202,7 +1202,7 @@ macro(find_path_recursive VARIABLE)
                         "look in.")
   endif(NOT _ARG_PATH)
   # get first level of dirs (needed to deal with PATH_SUFFIXES if present)
-  if (_ARG_PATH_SUFFIXES)
+  if(_ARG_PATH_SUFFIXES)
     set(_fst_subs)
     foreach(_psuf ${_ARG_PATH_SUFFIXES})
       file(TO_NATIVE_PATH "${_ARG_PATH}/${_psuf}" _psuf_path)

extras/pre_commit/pm3_csc/filecheck/cmake.py

@@ -32,14 +32,14 @@ class Cmake(base.FileCheck):
                                     "opening that block. That improves "+
                                     "readability plus future versions of "+
                                     "CMake will complain about this issue, "+
-                                    "too.\n", 15)
+                                    "too", 15)
 
     def CheckWhitespace(self, line):
         '''
         Check that there is no white space between a function call and its
         opening parenthesis.
         '''
-        openers = ['if']
+        openers = ['if', 'else', 'endif']
         for open_stmnt in openers:
             fopen_stmnt = r'(?:^|\s)' + open_stmnt + r'(\s*)\('
             m_stmnt = re.match(fopen_stmnt, line)
@@ -47,26 +47,20 @@ class Cmake(base.FileCheck):
                 stmnt_ws = m_stmnt.group(1)
                 if len(stmnt_ws):
                     pm3_csc.FailMsg("Line %d: " % self.current_line+
-                                    "No identifier in closing statement. The "+
-                                    "call to '%s()' should " % open_stmnt+
-                                    "go by the same name as the statement "+
-                                    "opening that block. That improves "+
-                                    "readability plus future versions of "+
-                                    "CMake will complain about this issue, "+
-                                    "too.\n", 15)
+                                    "White space(s) found between "+
+                                    "call to '%s' and its " % open_stmnt+
+                                    "opening parenthesis. Since in CMake "+
+                                    "this is a function/ macro call, "+
+                                    "omit the space", 16)
 
     def Check(self, ignore_line_width=False):
-        # For now we do not have any checks for reST so this is an awkward
-        # dummy, just checking line width.
-        # checks:
         #   for .cmake files: documentation of macros in index.rst
-        #   general: certain end statements should carry their name
-        #   general: parenthesis go without whitespace
         for line in self.GetLine(ignore_line_width):
             line = line.strip()
             m_line = re.match(r'([^#]*)', line)
             ex_line = m_line.group(1)
             if len(ex_line):
                 self.CheckClosingStatement(ex_line)
+                self.CheckWhitespace(line)
 
 __all__ = ('Cmake', )