ignore hidden .* files

ignore hidden .* files

git-svn-id: a7f2a8f7432d210e972fb03898013d213e2b549b@10378 e6417c60-b987-48fd-844e-b20f0fcc1017

--- seqan/util/cmake/FindSeqAn.cmake
+++ seqan/util/cmake/FindSeqAn.cmake
@@ -1,740 +1,740 @@
-# ===========================================================================
-# FindSeqAn.cmake -- Utilities for building SeqAn applications.
-# ===========================================================================
-
-# ---------------------------------------------------------------------------
-# Macro seqan_workshop_instrumentation_cmake ()
-# ---------------------------------------------------------------------------
-
-macro(seqan_instrumentation_cmake)
-	if(SEQAN_INSTRUMENTATION)
-	    message(STATUS "Prepare Instrumentation...")
-	    if(CMAKE_HOST_WIN32)
-	        execute_process(COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe cmake ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR})
-	        add_custom_target(seqan_instrumentation_build ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}
-	                          COMMENT "Build Instrumentation...")
-	    else(CMAKE_HOST_WIN32)
-	        execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py cmake ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR})
-	        add_custom_target(seqan_instrumentation_build ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}
-	                          COMMENT "Build Instrumentation...")
-	    endif(CMAKE_HOST_WIN32)
-	else(SEQAN_INSTRUMENTATION)
-		message(STATUS "SeqAn instrumentation deactivated.")
-	endif(SEQAN_INSTRUMENTATION)
-endmacro (seqan_instrumentation_cmake)
-
-
-# ---------------------------------------------------------------------------
-# Macro seqan_workshop_instrumentation_target (TARGET)
-# ---------------------------------------------------------------------------
-
-macro (seqan_instrumentation_target TARGET)
-	if(SEQAN_INSTRUMENTATION)
-	    add_dependencies(${TARGET} seqan_instrumentation_build)
-
-	    if(CMAKE_HOST_WIN32)
-	      add_custom_command(TARGET ${TARGET}
-	                         PRE_BUILD
-	                         COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe pre_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
-	                         COMMENT "Pre Build Instrumentation...")
-	      add_custom_command(TARGET ${TARGET}
-	                         POST_BUILD
-	                         COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe post_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
-	                         COMMENT "Post Build Instrumentation...")
-	    else(CMAKE_HOST_WIN32)
-	      add_custom_command(TARGET ${TARGET}
-	                         PRE_BUILD
-	                         COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py pre_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
-	                         COMMENT "Pre Build Instrumentation...")
-	      add_custom_command(TARGET ${TARGET}
-	                         POST_BUILD
-	                         COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py post_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
-	                         COMMENT "Post Build Instrumentation...")
-	    endif(CMAKE_HOST_WIN32)
-	endif(SEQAN_INSTRUMENTATION)
-endmacro (seqan_instrumentation_target TARGET)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_setup_global ()
-# ---------------------------------------------------------------------------
-
-# Global setup for SeqAn.
-#
-# This consists of setting the warning level and suppressing some warnings.
-
-macro (seqan_setup_global)
-    # This is used for calling anything in util.
-    set (SEQAN_ROOT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL
-         "Used to get the directory to util, for example." FORCE)
-
-    # -----------------------------------------------------------------------
-    # Check whether we compile with CLANG.
-    # -----------------------------------------------------------------------
-    set (COMPILER_IS_CLANG FALSE)
-    if (CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
-      set (COMPILER_IS_CLANG TRUE)
-    endif (CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
-
-    # -----------------------------------------------------------------------
-    # Fix CMAKE_COMPILER_IS_GNUCXX for MinGW.
-    # -----------------------------------------------------------------------
-
-    if (CMAKE_CXX_COMPILER MATCHES "g\\+\\+")
-      set (CMAKE_COMPILER_IS_GNUCXX TRUE)
-    endif (CMAKE_CXX_COMPILER MATCHES "g\\+\\+")
-
-    # -----------------------------------------------------------------------
-    # GCC Setup
-    # -----------------------------------------------------------------------
-    if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-        # For the GCC, enable warnings.
-        set (CMAKE_CXX_WARNING_LEVEL 4)
-        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wall -Wno-long-long -fstrict-aliasing -Wstrict-aliasing")
-        add_definitions (-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64)
-
-        # Determine GCC version.
-        # message("Determining GCC version.")
-        EXEC_PROGRAM(${CMAKE_CXX_COMPILER}
-                     ARGS --version
-                     OUTPUT_VARIABLE _GCC_VERSION)
-        STRING(REGEX REPLACE ".* ([0-9])\\.([0-9])\\.([0-9]) .*" "\\1\\2\\3"
-               _GCC_VERSION ${_GCC_VERSION})
-        # message("  GCC version is ${_GCC_VERSION}")
-
-        # Add -Wno-longlong if the GCC version is < 4.0.0.  Add -pedantic flag
-        # but disable warnings for variadic macros with GCC >= 4.0.0.  Earlier
-        # versions warn because of anonymous variadic macros in pedantic mode
-        # but do not have a flag to disable these warnings.
-        if (400 GREATER _GCC_VERSION)
-            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-long-long")
-        else (400 GREATER _GCC_VERSION)
-            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wno-variadic-macros")
-        endif (400 GREATER _GCC_VERSION)
-
-        # Force GCC to keep the frame pointer when debugging is enabled.
-        # This is mainly important for 64 bit but does not get into the way
-        # on 32 bit either at minimal performance impact.
-        set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer")
-        set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELEASE} -g -fno-omit-frame-pointer")
-
-        # Pass CXX flags to flags.
-        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_CXX_FLAGS_=\"${CMAKE_CXX_FLAGS}\"")
-    endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-
-    # -----------------------------------------------------------------------
-    # Visual Studio Setup
-    # -----------------------------------------------------------------------
-    if (MSVC)
-        # Warning level 3 for MSVC is disabled for now to see how much really bad warnings there are.
-        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3  /wd4996 -D_CRT_SECURE_NO_WARNINGS")
-        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W2  /wd4996 -D_CRT_SECURE_NO_WARNINGS")
-        # Disable Microsoft C++ language extensions.
-        # TODO(holtgrew): Re-disable again, Microsoft's header do not compile with this option! Look for a workaround.
-        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Za")
-    endif (MSVC)
-
-    # -----------------------------------------------------------------------
-    # Instrumentation
-    # -----------------------------------------------------------------------
-    seqan_instrumentation_cmake()
-endmacro (seqan_setup_global)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_setup_includes ()
-# ---------------------------------------------------------------------------
-
-# Setup an "include" directory, i.e. add it to the include directories via
-# add_includes() and register forward building for everything inside a
-# subdirectory "seqan".  Also registers it in variable SEQAN_LIBRARY_TARGETS.
-
-function (seqan_setup_includes REL_PATH TARGET_NAME)
-    set (PATH ${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH})
-    set (PATH_BIN ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH})
-    file (GLOB HEADERS_TMP ${PATH}/seqan/[A-z]*/[A-z]*.h)
-    file (GLOB SUPER_HEADERS ${PATH}/seqan/[A-z]*.h)
-
-    set (SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH} CACHE INTERNAL "asdf" FORCE)
-    # message("SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME} <- ${SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME}}")
-    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH})
-    include_directories(${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH})
-
-    set (SEQAN_LIBRARY_TARGETS ${TARGET_NAME} CACHE INTERNAL "asdf" FORCE)
-
-    foreach (HEADER ${HEADERS_TMP})
-        if (NOT ${HEADER} MATCHES ".*generated.*")
-            list (APPEND HEADERS ${HEADER})
-        else (NOT ${HEADER} MATCHES ".*generated.*")
-            list (APPEND FORWARDS ${HEADER})
-        endif (NOT ${HEADER} MATCHES ".*generated.*")
-    endforeach (HEADER ${HEADERS})
-
-    # Sort headers and forwards.
-    if (HEADERS)
-        list (SORT HEADERS)
-    endif (HEADERS)
-    if (FORWARDS)
-        list (SORT FORWARDS)
-    endif (FORWARDS)
-
-    # ---------------------------------------------------------------------------
-    # Forwards Generation.
-    # ---------------------------------------------------------------------------
-    if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-        file (GLOB BASE_CONTENTS RELATIVE ${PATH}/seqan ${PATH}/seqan/[A-z]*)
-        foreach (ENTRY ${BASE_CONTENTS})
-            if (IS_DIRECTORY ${PATH}/seqan/${ENTRY})
-                list (APPEND MODULES ${ENTRY})
-            endif (IS_DIRECTORY ${PATH}/seqan/${ENTRY})
-        endforeach (ENTRY ${SEQAN_BASE_CONTENTS})
-
-        if (MODULES)
-            list (SORT MODULES)
-            list (REMOVE_DUPLICATES MODULES)
-
-            # Build a list of generated forwards headers.  Goes into SEQAN_FORWARDS.
-            foreach (MODULE ${MODULES})
-                list (APPEND FORWARDS ${PATH_BIN}/seqan/${MODULE}/${MODULE}_generated_forwards.h)
-            endforeach (MODULE ${MODULES})
-
-            # Now tell CMake that the forward headers can be generated with
-            # build_forwards.py
-            add_custom_command (
-                OUTPUT ${FORWARDS}
-                COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/util/bin/build_forwards.py ${PATH}/seqan ${PATH_BIN}/seqan all
-                DEPENDS ${HEADERS})
-            #message(STATUS "add_custom_command (
-            #    OUTPUT ${FORWARDS}
-            #    COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/util/bin/build_forwards.py ${PATH}/seqan all
-            #    DEPENDS ${HEADERS})")
-        endif (MODULES)
-    endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-
-    # ---------------------------------------------------------------------------
-    # GUI Setup Stuff.
-    # ---------------------------------------------------------------------------
-    get_filename_component (BASE_ABS ${PATH}/seqan ABSOLUTE)
-
-    # CMake bug workaround: For Non-GUI generators there is a bug in cmake.
-    # The SOURCE command in add_custom_target is not recognized there.
-    set (NONGUI_GENERATORS "Unix Makefiles" "MinGW Makefiles")
-    list (FIND NONGUI_GENERATORS ${CMAKE_GENERATOR} FOUND)
-    if (FOUND EQUAL -1)
-        set (GUI_SOURCES SOURCES ${HEADERS} ${SUPER_HEADERS})
-    endif (FOUND EQUAL -1)
-
-    # Add SeqAn Pseudo Target for GUIs.
-    #
-    # This target contains all headers, forwards and umbrella headers.
-    add_custom_target(
-        ${TARGET_NAME}
-        DEPENDS ${HEADERS}
-                ${FORWARDS}
-                ${GUI_SOURCES}
-    )
-    #message("add_custom_target(${TARGET_NAME} DEPENDS ${HEADERS} ${FORWARDS} ${GUI_SOURCES})")
-
-    # Group library headers into modules.  The CMake documentation says this
-    # is mostly (only?) used for Visual Studio Projects.
-    foreach (HEADER ${HEADERS})
-        file (RELATIVE_PATH HEADER_REL ${BASE_ABS} ${HEADER})
-        get_filename_component (MODULE ${HEADER_REL} PATH)
-        source_group (${MODULE} FILES ${HEADER})
-        # message("source_group(${MODULE} FILES ${HEADER})")
-    endforeach (HEADER ${HEADERS})
-
-    # -----------------------------------------------------------------------
-    # Installation
-    # -----------------------------------------------------------------------
-    foreach (HEADER ${HEADERS} ${SUPER_HEADERS} ${FORWARDS})
-        string(REPLACE ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH}/seqan "" NEW_PATH ${HEADER})
-        string(REPLACE ${BASE_ABS} "" NEW_PATH ${NEW_PATH})
-        string(REPLACE "//" "/" NEW_PATH ${NEW_PATH})
-        install(FILES ${HEADER}
-                RENAME seqan${NEW_PATH}
-                DESTINATION include
-                COMPONENT headers)
-        #message("install(FILES ${HEADER} RENAME seqan${NEW_PATH} DESTINATION include COMPONENT dev)")
-    endforeach()
-endfunction (seqan_setup_includes)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_make_seqan_available ()
-# ---------------------------------------------------------------------------
-
-# Register a seqan extension that has been previously defined available.
-# TODO(holtgrew): Is order really important at all?
-
-function (seqan_make_seqan_available TARGET_NAME)
-   set (SEQAN_LIBRARY_TARGETS ${SEQAN_LIBRARY_TARGETS} ${TARGET_NAME} CACHE INTERNAL "asdf" FORCE)
-   foreach (x ${SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME}})
-     # message(include_directories(${x}))
-     include_directories(${x})
-   endforeach (x SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME})
-endfunction (seqan_make_seqan_available TARGET_NAME)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_setup_tests ()
-# ---------------------------------------------------------------------------
-
-# Switch to testing mode.  This function should be called in the
-# CMakeLists.txt in the tests directories before including subdirectories.
-#
-# The following will happen:
-#
-# * A target with the name TEST_TARGET will be created and dependencies
-#   of this target to subsequently targets added by seqan_add_test will
-#   be added.
-# * Setting definitions SEQAN_ENABLE_DEBUG=1 and SEQAN_ENABLE_TESTING=1.
-# * If the ${MODEL} variable is NightlyCoverage OR ExperimentalCoverage,
-#   and the compiler is GCC C++ then symbols for test coverate are added.
-
-macro (seqan_setup_tests TEST_TARGET)
-    # Setup flags for tests.
-    add_definitions(-DSEQAN_ENABLE_DEBUG=1)
-    add_definitions(-DSEQAN_ENABLE_TESTING=1)
-
-    # Add a target for the tests.
-    add_custom_target(${TEST_TARGET})
-    # Create a CMake variable for storing the current test target.
-    set (SEQAN_CURRENT_TEST_TARGET ${TEST_TARGET} CACHE INTERNAL
-         "Test target, communicated to seqan_add_test_executable" FORCE)
-    # message (STATUS "TEST_TARGET " ${TEST_TARGET})
-    # message (STATUS "SEQAN_CURRENT_TEST_TARGET " ${SEQAN_CURRENT_TEST_TARGET})
-
-    # Conditionally enable coverage mode.
-    if (MODEL STREQUAL "NightlyCoverage")
-        if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-            set (LDFLAGS "${LDFLAGS} -fprofile-arcs -ftest-coverage")
-            add_definitions(-DSEQAN_ENABLE_CHECKPOINTS=0)
-        endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-    endif (MODEL STREQUAL "NightlyCoverage")
-    if (MODEL STREQUAL "ExperimentalCoverage")
-        if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
-            set (LDFLAGS "${LDFLAGS} -fprofile-arcs -ftest-coverage")
-            add_definitions(-DSEQAN_ENABLE_CHECKPOINTS=0)
-        endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
-    endif (MODEL STREQUAL "ExperimentalCoverage")
-endmacro (seqan_setup_tests)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_setup_apps ()
-# ---------------------------------------------------------------------------
-
-# Initialize "apps" area.  This function should be called in the
-# CMakeLists.txt in the apps directories before including subdirectories.
-#
-# The following will happen:
-#
-# * A target with the name APP_TARGET will be created and dependencies
-#   of this target to subsequently targets added by seqan_add_test will
-#   be added.
-# * Setup the correct flags for Debug, Release and RelDebug mode.
-
-macro (seqan_setup_apps APP_TARGET)
-    # Set flags for SeqAn.
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_ENABLE_TESTING=0")
-    set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELDEBUG} -DSEQAN_ENABLE_DEBUG=0")
-    set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DSEQAN_ENABLE_DEBUG=0")
-    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSEQAN_ENABLE_DEBUG=1")
-
-    # Add a target for the tests.
-    add_custom_target(${APP_TARGET})
-    # Create a CMake variable for storing the current test target.
-    set (SEQAN_CURRENT_APP_TARGET ${APP_TARGET} CACHE INTERNAL
-         "App target, communicated to seqan_add_executable" FORCE)
-endmacro (seqan_setup_apps)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_setup_demos ()
-# ---------------------------------------------------------------------------
-
-# Initialize "demos" area.  This function should be called in the
-# CMakeLists.txt in the demos directories before including subdirectories.
-#
-# The following will happen:
-#
-# * A target with the name DEMO_TARGET will be created and dependencies of
-#   this target to subsequently targets added by seqan_add_executable will be
-#   added.
-# * Setup the correct flags for Debug, Release and RelDebug mode.
-
-macro (seqan_setup_demos DEMO_TARGET)
-    # Set flags for SeqAn.
-    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_ENABLE_TESTING=0")
-    set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELDEBUG} -DSEQAN_ENABLE_DEBUG=0")
-    set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DSEQAN_ENABLE_DEBUG=0")
-    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSEQAN_ENABLE_DEBUG=1")
-
-    # Add a target for the tests.
-    add_custom_target(${DEMO_TARGET})
-    # Create a CMake variable for storing the current test target.
-    set (SEQAN_CURRENT_APP_TARGET ${DEMO_TARGET} CACHE INTERNAL
-         "App target, communicated to seqan_add_executable" FORCE)
-endmacro (seqan_setup_demos)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_find_dependencies ()
-# ---------------------------------------------------------------------------
-
-# Try to find all dependencies using the find() function.
-#
-# Currently the libraries SeqAn can use to extend its functionality are:
-#
-#  * zlib
-#  * bzlib
-#  * OpenMP
-#  * CUDA
-
-macro (seqan_find_dependencies)
-  find_package (ZLIB QUIET)
-  if (ZLIB_FOUND)
-    add_definitions(-DSEQAN_HAS_ZLIB=1)
-    include_directories(${ZLIB_INCLUDE_DIRS})
-  endif (ZLIB_FOUND)
-
-  find_package (BZip2 QUIET)
-  if (BZIP2_FOUND)
-    include_directories(${BZIP_INCLUDE_DIRS})
-    add_definitions(-DSEQAN_HAS_BZIP2=1)
-  endif (BZIP2_FOUND)
-
-  find_package (OpenMP QUIET)
-  find_package (CUDA)
-  find_package (TR1)
-  find_package (Boost)
-  if (Boost_FOUND)
-    include_directories(${BOOST_INCLUDE_DIRS})
-  endif (Boost_FOUND)
-
-  if (CUDA_FOUND)
-    add_definitions(-DSEQAN_HAS_CUDA=1)
-  endif (CUDA_FOUND)
-
-  include(CheckIncludeFiles)
-  check_include_files(execinfo.h HAVE_EXECINFO)
-  if (HAVE_EXECINFO)
-    add_definitions(-DSEQAN_HAS_EXECINFO=1)
-  endif (HAVE_EXECINFO)
-endmacro (seqan_find_dependencies)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_add_all_subdirectories ()
-# ---------------------------------------------------------------------------
-
-# This macro calls add_subdirectory() for all subdirectories below
-# ${SEQAN_CURRENT_SOURCE_DIR} if they contain a CMakeLists.txt.
-#
-# Example:
-#
-#   seqan_add_all_subdirectories(seqan_tests)
-
-macro (seqan_add_all_subdirectories)
-    file (GLOB ENTRIES
-          RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-          ${CMAKE_CURRENT_SOURCE_DIR}/*)
-    foreach (ENTRY ${ENTRIES})
-        if (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY})
-            # message(STATUS "Going into ${ENTRY}")
-            if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY}/CMakeLists.txt)
-                add_subdirectory(${ENTRY})
-            endif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY}/CMakeLists.txt)
-        endif (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY})
-    endforeach (ENTRY ${ENTRIES})
-endmacro (seqan_add_all_subdirectories)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_project_just_include_all_subdirs ()
-# ---------------------------------------------------------------------------
-
-# Call this macro as the only command in a CMakeLists.txt file to include
-# all subdirectories.
-#
-# Args:
-#   PROJECT_NAME  String, the project name of this subdirectory.
-#
-# Example:
-#
-#   # Only line in file tests/CMakeLists.txt
-#   seqan_project_just_include_all_subdirs(seqan_tests)
-
-macro (seqan_project_just_include_all_subdirs PROJECT_NAME)
-    cmake_minimum_required (VERSION 2.6)
-    project(${PROJECT_NAME})
-    seqan_add_all_subdirectories()
-endmacro (seqan_project_just_include_all_subdirs)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_add_executable (TARGET_NAME source1.cpp source2.[cpp|h] ...)
-#       seqan_add_executable (TARGET_NAME)
-# ---------------------------------------------------------------------------
-
-# Create a SeqAn executable from the given source files.  If no such files
-# are given then all files in the current directory will be used.
-
-macro (seqan_add_executable TARGET_NAME)
-    # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
-    # message(STATUS "add_executable (${ARGV})")
-    add_executable (${ARGV})
-
-    add_dependencies(${SEQAN_CURRENT_APP_TARGET} ${ARGV0})
-
-    # Link against librt on Linux.
-  	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-    	target_link_libraries (${TARGET_NAME} rt)
-  	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-
-  	# Dependencies on all registered seqan extensions.
-  	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
-    # message(STATUS "add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})")
-
-    # -----------------------------------------------------------------------
-    # Instrumentation
-    # -----------------------------------------------------------------------
-    seqan_instrumentation_target(${ARGV0})
-
-  	# Link against zlib and bzlib if found.
-  	if (ZLIB_FOUND)
-  	    include_directories (${ZLIB_INCLUDE_DIR})
-  	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
-  	endif (ZLIB_FOUND)
-  	if (BZIP2_FOUND)
-  	    include_directories (${BZIP2_INCLUDE_DIR})
-  	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
-  	endif (BZIP2_FOUND)
-endmacro (seqan_add_executable TARGET_NAME)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_add_test_executable (TARGET_NAME source1.cpp source2.[cpp|h])
-#       seqan_add_test_executable (TARGET_NAME)
-# ---------------------------------------------------------------------------
-
-# Create a SeqAn executable from the given source files.  If no such files
-# are given then all files in the current directory will be used.
-#
-# Also the test will be registered with add_test and depend on the current
-# test target, i.e. from closest seqan_setup_tests(TEST_TARGET_NAME) call.
-
-macro (seqan_add_test_executable TARGET_NAME)
-    # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
-    # message(STATUS "add_executable (${ARGV})")
-    add_executable (${ARGV})
-    add_test(test_${ARGV0} ${ARGV0})
-
-    add_dependencies(${SEQAN_CURRENT_TEST_TARGET} ${ARGV0})
-
-    # Link against librt on Linux.
-  	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-  		  target_link_libraries (${ARGV0} rt)
-  	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-
-  	# Dependencies on all registered seqan extensions.
-    # message("add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})")
-  	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
-
-    # -----------------------------------------------------------------------
-    # Instrumentation
-    # -----------------------------------------------------------------------
-    seqan_instrumentation_target(${ARGV0})
-
-  	# Link against zlib and bzlib if found.
-  	if (ZLIB_FOUND)
-  	    include_directories (${ZLIB_INCLUDE_DIR})
-  	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
-  	endif (ZLIB_FOUND)
-  	if (BZIP2_FOUND)
-  	    include_directories (${BZIP2_INCLUDE_DIR})
-  	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
-  	endif (BZIP2_FOUND)
-endmacro (seqan_add_test_executable TARGET_NAME)
-
-# ---------------------------------------------------------------------------
-# Function seqan_add_cuda_executable (TARGET_NAME source1.cu source2.[cu|cpp|h])
-#          seqan_add_cuda_executable (TARGET_NAME)
-# ---------------------------------------------------------------------------
-
-function (seqan_add_cuda_executable TARGET_NAME)
-    if (CUDA_FOUND)
-        # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
-
-        # -------------------------------------------------------------------
-        # Set CUDA variables
-        # -------------------------------------------------------------------
-        set (CUDA_PROPAGATE_HOST_FLAGS OFF)
-        set (CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE OFF)
-        #set (CUDA_NVCC_FLAGS "-pg")
-        list (APPEND CMAKE_CXX_SOURCE_FILE_EXTENSIONS "cu")
-        cuda_include_directories(${CUDA_CUT_INCLUDE_DIR})
-        #string (REGEX REPLACE "\\-(W( |all)|pedantic)" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
-        string (REGEX REPLACE "\\-pedantic" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
-
-        # -------------------------------------------------------------------
-        # Go on normally as in apps.
-        # -------------------------------------------------------------------
-        # message(STATUS "cuda_add_executable (${ARGV})")
-        cuda_add_executable (${ARGV})
-
-        add_dependencies(${SEQAN_CURRENT_APP_TARGET} ${ARGV0})
-
-        # Link against librt on Linux.
-      	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-        	target_link_libraries (${TARGET_NAME} rt)
-      	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-
-      	# Dependencies on all registered seqan extensions.
-      	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
-
-        # -----------------------------------------------------------------------
-        # Instrumentation
-        # -----------------------------------------------------------------------
-	seqan_instrumentation_target(${ARGV0})
-
-      	# Link against zlib and bzlib if found.
-      	if (ZLIB_FOUND)
-      	    include_directories (${ZLIB_INCLUDE_DIR})
-      	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
-      	endif (ZLIB_FOUND)
-      	if (BZIP2_FOUND)
-      	    include_directories (${BZIP2_INCLUDE_DIR})
-      	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
-      	endif (BZIP2_FOUND)
-    endif (CUDA_FOUND)
-endfunction (seqan_add_cuda_executable TARGET_NAME)
-
-# ---------------------------------------------------------------------------
-# Function seqan_add_cuda_test_executable (TARGET_NAME source1.cu source2.[cu|cpp|h])
-#          seqan_add_cuda_test_executable (TARGET_NAME)
-# ---------------------------------------------------------------------------
-
-# Create a SeqAn CUDA executable from the given source files.  If no such
-# files are given then all files in the current directory will be used.
-#
-# Also the test will be registered with add_test and depend on the current
-# test target, i.e. from closest seqan_setup_tests(TEST_TARGET_NAME) call.
-#
-# Only adds target if CUDA_FOUND is set to true.
-
-function (seqan_add_cuda_test_executable TARGET_NAME)
-    if (CUDA_FOUND)
-        # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
-
-        # -------------------------------------------------------------------
-        # Set CUDA variables
-        # -------------------------------------------------------------------
-        set (CUDA_PROPAGATE_HOST_FLAGS OFF)
-        set (CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE OFF)
-        #set (CUDA_NVCC_FLAGS "-pg")
-        list (APPEND CMAKE_CXX_SOURCE_FILE_EXTENSIONS "cu")
-        cuda_include_directories(${CUDA_CUT_INCLUDE_DIR})
-        #string (REGEX REPLACE "\\-(W( |all)|pedantic)" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
-        string (REGEX REPLACE "\\-pedantic" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
-
-        # -------------------------------------------------------------------
-        # Go on normally as in apps.
-        # -------------------------------------------------------------------
-        # message(STATUS "cuda_add_executable (${ARGV})")
-        cuda_add_executable (${ARGV})
-        add_test(test_${ARGV0} ${ARGV0})
-
-        add_dependencies(${SEQAN_CURRENT_TEST_TARGET} ${ARGV0})
-
-        # Link against librt on Linux.
-      	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-        	target_link_libraries (${TARGET_NAME} rt)
-      	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-
-      	# Dependencies on all registered seqan extensions.
-      	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
-
-        # -----------------------------------------------------------------------
-        # Instrumentation
-        # -----------------------------------------------------------------------
-	seqan_instrumentation_target(${ARGV0})
-
-      	# Link against zlib and bzlib if found.
-      	if (ZLIB_FOUND)
-      	    include_directories (${ZLIB_INCLUDE_DIR})
-      	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
-      	endif (ZLIB_FOUND)
-      	if (BZIP2_FOUND)
-      	    include_directories (${BZIP2_INCLUDE_DIR})
-      	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
-      	endif (BZIP2_FOUND)
-    endif (CUDA_FOUND)
-endfunction (seqan_add_cuda_test_executable TARGET_NAME)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_add_all_executables ([TARGET])
-# ---------------------------------------------------------------------------
-
-# This macro calls seqan_add_executable() for all all .cpp files in the
-# current directory.  If the optional TARGET parameter is given, a target
-# with this name is created and the executable targets will depend on this
-# target.
-#
-# Example:
-#
-#   seqan_add_all_executables()
-#   seqan_add_all_executables(depend_on_this)
-#   seqan_add_all_executables(depend_on_this prefix)
-
-macro (seqan_add_all_executables)
-    file (GLOB ENTRIES
-          RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-          ${CMAKE_CURRENT_SOURCE_DIR}/*.cpp)
-    if (${ARGC} GREATER 1)
-        set (PREFIX ${ARGV1})
-    endif (${ARGC} GREATER 1)
-    if (${ARGC} GREATER 0)
-        if (TARGET ${ARGV0})  # Add target only if it does not exist yet.
-        else (TARGET ${ARGV0})
-            add_custom_target(${ARGV0})
-        endif (TARGET ${ARGV0})
-    endif (${ARGC} GREATER 0)
-    foreach (ENTRY ${ENTRIES})
-        get_filename_component(BIN_NAME ${ENTRY} NAME_WE)
-        seqan_add_executable(${PREFIX}${BIN_NAME} ${ENTRY})
-        if (${ARGC} GREATER 0)
-            add_dependencies(${ARGV0} ${PREFIX}${BIN_NAME})
-        endif (${ARGC} GREATER 0)
-    endforeach (ENTRY ${ENTRIES})
-endmacro (seqan_add_all_executables)
-
-# ---------------------------------------------------------------------------
-# Macro seqan_add_all_cuda_executables ([TARGET])
-# ---------------------------------------------------------------------------
-
-# This macro calls seqan_add_cuda_executable() for all all .cu files in the
-# current directory.  If the optional TARGET parameter is given, a target
-# with this name is created and the executable targets will depend on this
-# target.
-#
-# Only adds target if CUDA_FOUND is set to true.
-#
-# Example:
-#
-#   seqan_add_all_cuda_executables()
-#   seqan_add_all_cuda_executables(depend_on_this)
-
-macro (seqan_add_all_cuda_executables)
-    if (CUDA_FOUND)
-        file (GLOB ENTRIES
-              RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
-              ${CMAKE_CURRENT_SOURCE_DIR}/*.cu)
-        if (${ARGC} GREATER 0)
-            if (TARGET ${ARGV0})  # Add target only if it does not exist yet.
-            else (TARGET ${ARGV0})
-                add_custom_target(${ARGV0})
-            endif (TARGET ${ARGV0})
-        endif (${ARGC} GREATER 0)
-        foreach (ENTRY ${ENTRIES})
-            get_filename_component(BIN_NAME ${ENTRY} NAME_WE)
-            # message("seqan_add_cuda_executable(${BIN_NAME} ${ENTRY})")
-            seqan_add_cuda_executable(${BIN_NAME} ${ENTRY})
-            if (${ARGC} GREATER 0)
-                add_dependencies(${ARGV0} ${BIN_NAME})
-            endif (${ARGC} GREATER 0)
-        endforeach (ENTRY ${ENTRIES})
-    endif (CUDA_FOUND)
-endmacro (seqan_add_all_cuda_executables)
+# ===========================================================================
+# FindSeqAn.cmake -- Utilities for building SeqAn applications.
+# ===========================================================================
+
+# ---------------------------------------------------------------------------
+# Macro seqan_workshop_instrumentation_cmake ()
+# ---------------------------------------------------------------------------
+
+macro(seqan_instrumentation_cmake)
+	if(SEQAN_INSTRUMENTATION)
+	    message(STATUS "Prepare Instrumentation...")
+	    if(CMAKE_HOST_WIN32)
+	        execute_process(COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe cmake ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR})
+	        add_custom_target(seqan_instrumentation_build ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}
+	                          COMMENT "Build Instrumentation...")
+	    else(CMAKE_HOST_WIN32)
+	        execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py cmake ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR})
+	        add_custom_target(seqan_instrumentation_build ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR}
+	                          COMMENT "Build Instrumentation...")
+	    endif(CMAKE_HOST_WIN32)
+	else(SEQAN_INSTRUMENTATION)
+		message(STATUS "SeqAn instrumentation deactivated.")
+	endif(SEQAN_INSTRUMENTATION)
+endmacro (seqan_instrumentation_cmake)
+
+
+# ---------------------------------------------------------------------------
+# Macro seqan_workshop_instrumentation_target (TARGET)
+# ---------------------------------------------------------------------------
+
+macro (seqan_instrumentation_target TARGET)
+	if(SEQAN_INSTRUMENTATION)
+	    add_dependencies(${TARGET} seqan_instrumentation_build)
+
+	    if(CMAKE_HOST_WIN32)
+	      add_custom_command(TARGET ${TARGET}
+	                         PRE_BUILD
+	                         COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe pre_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
+	                         COMMENT "Pre Build Instrumentation...")
+	      add_custom_command(TARGET ${TARGET}
+	                         POST_BUILD
+	                         COMMAND ${CMAKE_SOURCE_DIR}/misc/seqan_instrumentation/py2exe/dist/seqan_instrumentation.exe post_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
+	                         COMMENT "Post Build Instrumentation...")
+	    else(CMAKE_HOST_WIN32)
+	      add_custom_command(TARGET ${TARGET}
+	                         PRE_BUILD
+	                         COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py pre_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
+	                         COMMENT "Pre Build Instrumentation...")
+	      add_custom_command(TARGET ${TARGET}
+	                         POST_BUILD
+	                         COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/misc/seqan_instrumentation/bin/seqan_instrumentation.py post_build ${CMAKE_BINARY_DIR} ${CMAKE_SOURCE_DIR} ${TARGET}
+	                         COMMENT "Post Build Instrumentation...")
+	    endif(CMAKE_HOST_WIN32)
+	endif(SEQAN_INSTRUMENTATION)
+endmacro (seqan_instrumentation_target TARGET)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_setup_global ()
+# ---------------------------------------------------------------------------
+
+# Global setup for SeqAn.
+#
+# This consists of setting the warning level and suppressing some warnings.
+
+macro (seqan_setup_global)
+    # This is used for calling anything in util.
+    set (SEQAN_ROOT_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR} CACHE INTERNAL
+         "Used to get the directory to util, for example." FORCE)
+
+    # -----------------------------------------------------------------------
+    # Check whether we compile with CLANG.
+    # -----------------------------------------------------------------------
+    set (COMPILER_IS_CLANG FALSE)
+    if (CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
+      set (COMPILER_IS_CLANG TRUE)
+    endif (CMAKE_CXX_COMPILER MATCHES "clang\\+\\+")
+
+    # -----------------------------------------------------------------------
+    # Fix CMAKE_COMPILER_IS_GNUCXX for MinGW.
+    # -----------------------------------------------------------------------
+
+    if (CMAKE_CXX_COMPILER MATCHES "g\\+\\+")
+      set (CMAKE_COMPILER_IS_GNUCXX TRUE)
+    endif (CMAKE_CXX_COMPILER MATCHES "g\\+\\+")
+
+    # -----------------------------------------------------------------------
+    # GCC Setup
+    # -----------------------------------------------------------------------
+    if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+        # For the GCC, enable warnings.
+        set (CMAKE_CXX_WARNING_LEVEL 4)
+        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -W -Wall -Wno-long-long -fstrict-aliasing -Wstrict-aliasing")
+        add_definitions (-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64)
+
+        # Determine GCC version.
+        # message("Determining GCC version.")
+        EXEC_PROGRAM(${CMAKE_CXX_COMPILER}
+                     ARGS --version
+                     OUTPUT_VARIABLE _GCC_VERSION)
+        STRING(REGEX REPLACE ".* ([0-9])\\.([0-9])\\.([0-9]) .*" "\\1\\2\\3"
+               _GCC_VERSION ${_GCC_VERSION})
+        # message("  GCC version is ${_GCC_VERSION}")
+
+        # Add -Wno-longlong if the GCC version is < 4.0.0.  Add -pedantic flag
+        # but disable warnings for variadic macros with GCC >= 4.0.0.  Earlier
+        # versions warn because of anonymous variadic macros in pedantic mode
+        # but do not have a flag to disable these warnings.
+        if (400 GREATER _GCC_VERSION)
+            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-long-long")
+        else (400 GREATER _GCC_VERSION)
+            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pedantic -Wno-variadic-macros")
+        endif (400 GREATER _GCC_VERSION)
+
+        # Force GCC to keep the frame pointer when debugging is enabled.
+        # This is mainly important for 64 bit but does not get into the way
+        # on 32 bit either at minimal performance impact.
+        set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-omit-frame-pointer")
+        set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELEASE} -g -fno-omit-frame-pointer")
+
+        # Pass CXX flags to flags.
+        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_CXX_FLAGS_=\"${CMAKE_CXX_FLAGS}\"")
+    endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+
+    # -----------------------------------------------------------------------
+    # Visual Studio Setup
+    # -----------------------------------------------------------------------
+    if (MSVC)
+        # Warning level 3 for MSVC is disabled for now to see how much really bad warnings there are.
+        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W3  /wd4996 -D_CRT_SECURE_NO_WARNINGS")
+        set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W2  /wd4996 -D_CRT_SECURE_NO_WARNINGS")
+        # Disable Microsoft C++ language extensions.
+        # TODO(holtgrew): Re-disable again, Microsoft's header do not compile with this option! Look for a workaround.
+        #set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /Za")
+    endif (MSVC)
+
+    # -----------------------------------------------------------------------
+    # Instrumentation
+    # -----------------------------------------------------------------------
+    seqan_instrumentation_cmake()
+endmacro (seqan_setup_global)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_setup_includes ()
+# ---------------------------------------------------------------------------
+
+# Setup an "include" directory, i.e. add it to the include directories via
+# add_includes() and register forward building for everything inside a
+# subdirectory "seqan".  Also registers it in variable SEQAN_LIBRARY_TARGETS.
+
+function (seqan_setup_includes REL_PATH TARGET_NAME)
+    set (PATH ${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH})
+    set (PATH_BIN ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH})
+    file (GLOB HEADERS_TMP ${PATH}/seqan/[A-z]*/[A-z]*.h)
+    file (GLOB SUPER_HEADERS ${PATH}/seqan/[A-z]*.h)
+
+    set (SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME} ${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH} ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH} CACHE INTERNAL "asdf" FORCE)
+    # message("SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME} <- ${SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME}}")
+    include_directories(${CMAKE_CURRENT_SOURCE_DIR}/${REL_PATH})
+    include_directories(${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH})
+
+    set (SEQAN_LIBRARY_TARGETS ${TARGET_NAME} CACHE INTERNAL "asdf" FORCE)
+
+    foreach (HEADER ${HEADERS_TMP})
+        if (NOT ${HEADER} MATCHES ".*generated.*")
+            list (APPEND HEADERS ${HEADER})
+        else (NOT ${HEADER} MATCHES ".*generated.*")
+            list (APPEND FORWARDS ${HEADER})
+        endif (NOT ${HEADER} MATCHES ".*generated.*")
+    endforeach (HEADER ${HEADERS})
+
+    # Sort headers and forwards.
+    if (HEADERS)
+        list (SORT HEADERS)
+    endif (HEADERS)
+    if (FORWARDS)
+        list (SORT FORWARDS)
+    endif (FORWARDS)
+
+    # ---------------------------------------------------------------------------
+    # Forwards Generation.
+    # ---------------------------------------------------------------------------
+    if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+        file (GLOB BASE_CONTENTS RELATIVE ${PATH}/seqan ${PATH}/seqan/[A-z]*)
+        foreach (ENTRY ${BASE_CONTENTS})
+            if (IS_DIRECTORY ${PATH}/seqan/${ENTRY})
+                list (APPEND MODULES ${ENTRY})
+            endif (IS_DIRECTORY ${PATH}/seqan/${ENTRY})
+        endforeach (ENTRY ${SEQAN_BASE_CONTENTS})
+
+        if (MODULES)
+            list (SORT MODULES)
+            list (REMOVE_DUPLICATES MODULES)
+
+            # Build a list of generated forwards headers.  Goes into SEQAN_FORWARDS.
+            foreach (MODULE ${MODULES})
+                list (APPEND FORWARDS ${PATH_BIN}/seqan/${MODULE}/${MODULE}_generated_forwards.h)
+            endforeach (MODULE ${MODULES})
+
+            # Now tell CMake that the forward headers can be generated with
+            # build_forwards.py
+            add_custom_command (
+                OUTPUT ${FORWARDS}
+                COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/util/bin/build_forwards.py ${PATH}/seqan ${PATH_BIN}/seqan all
+                DEPENDS ${HEADERS})
+            #message(STATUS "add_custom_command (
+            #    OUTPUT ${FORWARDS}
+            #    COMMAND ${PYTHON_EXECUTABLE} ${SEQAN_ROOT_SOURCE_DIR}/util/bin/build_forwards.py ${PATH}/seqan all
+            #    DEPENDS ${HEADERS})")
+        endif (MODULES)
+    endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+
+    # ---------------------------------------------------------------------------
+    # GUI Setup Stuff.
+    # ---------------------------------------------------------------------------
+    get_filename_component (BASE_ABS ${PATH}/seqan ABSOLUTE)
+
+    # CMake bug workaround: For Non-GUI generators there is a bug in cmake.
+    # The SOURCE command in add_custom_target is not recognized there.
+    set (NONGUI_GENERATORS "Unix Makefiles" "MinGW Makefiles")
+    list (FIND NONGUI_GENERATORS ${CMAKE_GENERATOR} FOUND)
+    if (FOUND EQUAL -1)
+        set (GUI_SOURCES SOURCES ${HEADERS} ${SUPER_HEADERS})
+    endif (FOUND EQUAL -1)
+
+    # Add SeqAn Pseudo Target for GUIs.
+    #
+    # This target contains all headers, forwards and umbrella headers.
+    add_custom_target(
+        ${TARGET_NAME}
+        DEPENDS ${HEADERS}
+                ${FORWARDS}
+                ${GUI_SOURCES}
+    )
+    #message("add_custom_target(${TARGET_NAME} DEPENDS ${HEADERS} ${FORWARDS} ${GUI_SOURCES})")
+
+    # Group library headers into modules.  The CMake documentation says this
+    # is mostly (only?) used for Visual Studio Projects.
+    foreach (HEADER ${HEADERS})
+        file (RELATIVE_PATH HEADER_REL ${BASE_ABS} ${HEADER})
+        get_filename_component (MODULE ${HEADER_REL} PATH)
+        source_group (${MODULE} FILES ${HEADER})
+        # message("source_group(${MODULE} FILES ${HEADER})")
+    endforeach (HEADER ${HEADERS})
+
+    # -----------------------------------------------------------------------
+    # Installation
+    # -----------------------------------------------------------------------
+    foreach (HEADER ${HEADERS} ${SUPER_HEADERS} ${FORWARDS})
+        string(REPLACE ${CMAKE_CURRENT_BINARY_DIR}/${REL_PATH}/seqan "" NEW_PATH ${HEADER})
+        string(REPLACE ${BASE_ABS} "" NEW_PATH ${NEW_PATH})
+        string(REPLACE "//" "/" NEW_PATH ${NEW_PATH})
+        install(FILES ${HEADER}
+                RENAME seqan${NEW_PATH}
+                DESTINATION include
+                COMPONENT headers)
+        #message("install(FILES ${HEADER} RENAME seqan${NEW_PATH} DESTINATION include COMPONENT dev)")
+    endforeach()
+endfunction (seqan_setup_includes)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_make_seqan_available ()
+# ---------------------------------------------------------------------------
+
+# Register a seqan extension that has been previously defined available.
+# TODO(holtgrew): Is order really important at all?
+
+function (seqan_make_seqan_available TARGET_NAME)
+   set (SEQAN_LIBRARY_TARGETS ${SEQAN_LIBRARY_TARGETS} ${TARGET_NAME} CACHE INTERNAL "asdf" FORCE)
+   foreach (x ${SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME}})
+     # message(include_directories(${x}))
+     include_directories(${x})
+   endforeach (x SEQAN_INCLUDE_DIR_FOR_${TARGET_NAME})
+endfunction (seqan_make_seqan_available TARGET_NAME)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_setup_tests ()
+# ---------------------------------------------------------------------------
+
+# Switch to testing mode.  This function should be called in the
+# CMakeLists.txt in the tests directories before including subdirectories.
+#
+# The following will happen:
+#
+# * A target with the name TEST_TARGET will be created and dependencies
+#   of this target to subsequently targets added by seqan_add_test will
+#   be added.
+# * Setting definitions SEQAN_ENABLE_DEBUG=1 and SEQAN_ENABLE_TESTING=1.
+# * If the ${MODEL} variable is NightlyCoverage OR ExperimentalCoverage,
+#   and the compiler is GCC C++ then symbols for test coverate are added.
+
+macro (seqan_setup_tests TEST_TARGET)
+    # Setup flags for tests.
+    add_definitions(-DSEQAN_ENABLE_DEBUG=1)
+    add_definitions(-DSEQAN_ENABLE_TESTING=1)
+
+    # Add a target for the tests.
+    add_custom_target(${TEST_TARGET})
+    # Create a CMake variable for storing the current test target.
+    set (SEQAN_CURRENT_TEST_TARGET ${TEST_TARGET} CACHE INTERNAL
+         "Test target, communicated to seqan_add_test_executable" FORCE)
+    # message (STATUS "TEST_TARGET " ${TEST_TARGET})
+    # message (STATUS "SEQAN_CURRENT_TEST_TARGET " ${SEQAN_CURRENT_TEST_TARGET})
+
+    # Conditionally enable coverage mode.
+    if (MODEL STREQUAL "NightlyCoverage")
+        if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+            set (LDFLAGS "${LDFLAGS} -fprofile-arcs -ftest-coverage")
+            add_definitions(-DSEQAN_ENABLE_CHECKPOINTS=0)
+        endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+    endif (MODEL STREQUAL "NightlyCoverage")
+    if (MODEL STREQUAL "ExperimentalCoverage")
+        if (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+            set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage")
+            set (LDFLAGS "${LDFLAGS} -fprofile-arcs -ftest-coverage")
+            add_definitions(-DSEQAN_ENABLE_CHECKPOINTS=0)
+        endif (CMAKE_COMPILER_IS_GNUCXX OR COMPILER_IS_CLANG)
+    endif (MODEL STREQUAL "ExperimentalCoverage")
+endmacro (seqan_setup_tests)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_setup_apps ()
+# ---------------------------------------------------------------------------
+
+# Initialize "apps" area.  This function should be called in the
+# CMakeLists.txt in the apps directories before including subdirectories.
+#
+# The following will happen:
+#
+# * A target with the name APP_TARGET will be created and dependencies
+#   of this target to subsequently targets added by seqan_add_test will
+#   be added.
+# * Setup the correct flags for Debug, Release and RelDebug mode.
+
+macro (seqan_setup_apps APP_TARGET)
+    # Set flags for SeqAn.
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_ENABLE_TESTING=0")
+    set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELDEBUG} -DSEQAN_ENABLE_DEBUG=0")
+    set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DSEQAN_ENABLE_DEBUG=0")
+    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSEQAN_ENABLE_DEBUG=1")
+
+    # Add a target for the tests.
+    add_custom_target(${APP_TARGET})
+    # Create a CMake variable for storing the current test target.
+    set (SEQAN_CURRENT_APP_TARGET ${APP_TARGET} CACHE INTERNAL
+         "App target, communicated to seqan_add_executable" FORCE)
+endmacro (seqan_setup_apps)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_setup_demos ()
+# ---------------------------------------------------------------------------
+
+# Initialize "demos" area.  This function should be called in the
+# CMakeLists.txt in the demos directories before including subdirectories.
+#
+# The following will happen:
+#
+# * A target with the name DEMO_TARGET will be created and dependencies of
+#   this target to subsequently targets added by seqan_add_executable will be
+#   added.
+# * Setup the correct flags for Debug, Release and RelDebug mode.
+
+macro (seqan_setup_demos DEMO_TARGET)
+    # Set flags for SeqAn.
+    set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DSEQAN_ENABLE_TESTING=0")
+    set (CMAKE_CXX_FLAGS_RELDEBUG "${CMAKE_CXX_FLAGS_RELDEBUG} -DSEQAN_ENABLE_DEBUG=0")
+    set (CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -DSEQAN_ENABLE_DEBUG=0")
+    set (CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -DSEQAN_ENABLE_DEBUG=1")
+
+    # Add a target for the tests.
+    add_custom_target(${DEMO_TARGET})
+    # Create a CMake variable for storing the current test target.
+    set (SEQAN_CURRENT_APP_TARGET ${DEMO_TARGET} CACHE INTERNAL
+         "App target, communicated to seqan_add_executable" FORCE)
+endmacro (seqan_setup_demos)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_find_dependencies ()
+# ---------------------------------------------------------------------------
+
+# Try to find all dependencies using the find() function.
+#
+# Currently the libraries SeqAn can use to extend its functionality are:
+#
+#  * zlib
+#  * bzlib
+#  * OpenMP
+#  * CUDA
+
+macro (seqan_find_dependencies)
+  find_package (ZLIB QUIET)
+  if (ZLIB_FOUND)
+    add_definitions(-DSEQAN_HAS_ZLIB=1)
+    include_directories(${ZLIB_INCLUDE_DIRS})
+  endif (ZLIB_FOUND)
+
+  find_package (BZip2 QUIET)
+  if (BZIP2_FOUND)
+    include_directories(${BZIP_INCLUDE_DIRS})
+    add_definitions(-DSEQAN_HAS_BZIP2=1)
+  endif (BZIP2_FOUND)
+
+  find_package (OpenMP QUIET)
+  find_package (CUDA)
+  find_package (TR1)
+  find_package (Boost)
+  if (Boost_FOUND)
+    include_directories(${BOOST_INCLUDE_DIRS})
+  endif (Boost_FOUND)
+
+  if (CUDA_FOUND)
+    add_definitions(-DSEQAN_HAS_CUDA=1)
+  endif (CUDA_FOUND)
+
+  include(CheckIncludeFiles)
+  check_include_files(execinfo.h HAVE_EXECINFO)
+  if (HAVE_EXECINFO)
+    add_definitions(-DSEQAN_HAS_EXECINFO=1)
+  endif (HAVE_EXECINFO)
+endmacro (seqan_find_dependencies)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_add_all_subdirectories ()
+# ---------------------------------------------------------------------------
+
+# This macro calls add_subdirectory() for all subdirectories below
+# ${SEQAN_CURRENT_SOURCE_DIR} if they contain a CMakeLists.txt.
+#
+# Example:
+#
+#   seqan_add_all_subdirectories(seqan_tests)
+
+macro (seqan_add_all_subdirectories)
+    file (GLOB ENTRIES
+          RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+          ${CMAKE_CURRENT_SOURCE_DIR}/*)
+    foreach (ENTRY ${ENTRIES})
+        if (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY})
+            # message(STATUS "Going into ${ENTRY}")
+            if (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY}/CMakeLists.txt)
+                add_subdirectory(${ENTRY})
+            endif (EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY}/CMakeLists.txt)
+        endif (IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${ENTRY})
+    endforeach (ENTRY ${ENTRIES})
+endmacro (seqan_add_all_subdirectories)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_project_just_include_all_subdirs ()
+# ---------------------------------------------------------------------------
+
+# Call this macro as the only command in a CMakeLists.txt file to include
+# all subdirectories.
+#
+# Args:
+#   PROJECT_NAME  String, the project name of this subdirectory.
+#
+# Example:
+#
+#   # Only line in file tests/CMakeLists.txt
+#   seqan_project_just_include_all_subdirs(seqan_tests)
+
+macro (seqan_project_just_include_all_subdirs PROJECT_NAME)
+    cmake_minimum_required (VERSION 2.6)
+    project(${PROJECT_NAME})
+    seqan_add_all_subdirectories()
+endmacro (seqan_project_just_include_all_subdirs)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_add_executable (TARGET_NAME source1.cpp source2.[cpp|h] ...)
+#       seqan_add_executable (TARGET_NAME)
+# ---------------------------------------------------------------------------
+
+# Create a SeqAn executable from the given source files.  If no such files
+# are given then all files in the current directory will be used.
+
+macro (seqan_add_executable TARGET_NAME)
+    # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
+    # message(STATUS "add_executable (${ARGV})")
+    add_executable (${ARGV})
+
+    add_dependencies(${SEQAN_CURRENT_APP_TARGET} ${ARGV0})
+
+    # Link against librt on Linux.
+  	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+    	target_link_libraries (${TARGET_NAME} rt)
+  	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+  	# Dependencies on all registered seqan extensions.
+  	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
+    # message(STATUS "add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})")
+
+    # -----------------------------------------------------------------------
+    # Instrumentation
+    # -----------------------------------------------------------------------
+    seqan_instrumentation_target(${ARGV0})
+
+  	# Link against zlib and bzlib if found.
+  	if (ZLIB_FOUND)
+  	    include_directories (${ZLIB_INCLUDE_DIR})
+  	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
+  	endif (ZLIB_FOUND)
+  	if (BZIP2_FOUND)
+  	    include_directories (${BZIP2_INCLUDE_DIR})
+  	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
+  	endif (BZIP2_FOUND)
+endmacro (seqan_add_executable TARGET_NAME)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_add_test_executable (TARGET_NAME source1.cpp source2.[cpp|h])
+#       seqan_add_test_executable (TARGET_NAME)
+# ---------------------------------------------------------------------------
+
+# Create a SeqAn executable from the given source files.  If no such files
+# are given then all files in the current directory will be used.
+#
+# Also the test will be registered with add_test and depend on the current
+# test target, i.e. from closest seqan_setup_tests(TEST_TARGET_NAME) call.
+
+macro (seqan_add_test_executable TARGET_NAME)
+    # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
+    # message(STATUS "add_executable (${ARGV})")
+    add_executable (${ARGV})
+    add_test(test_${ARGV0} ${ARGV0})
+
+    add_dependencies(${SEQAN_CURRENT_TEST_TARGET} ${ARGV0})
+
+    # Link against librt on Linux.
+  	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+  		  target_link_libraries (${ARGV0} rt)
+  	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+  	# Dependencies on all registered seqan extensions.
+    # message("add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})")
+  	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
+
+    # -----------------------------------------------------------------------
+    # Instrumentation
+    # -----------------------------------------------------------------------
+    seqan_instrumentation_target(${ARGV0})
+
+  	# Link against zlib and bzlib if found.
+  	if (ZLIB_FOUND)
+  	    include_directories (${ZLIB_INCLUDE_DIR})
+  	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
+  	endif (ZLIB_FOUND)
+  	if (BZIP2_FOUND)
+  	    include_directories (${BZIP2_INCLUDE_DIR})
+  	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
+  	endif (BZIP2_FOUND)
+endmacro (seqan_add_test_executable TARGET_NAME)
+
+# ---------------------------------------------------------------------------
+# Function seqan_add_cuda_executable (TARGET_NAME source1.cu source2.[cu|cpp|h])
+#          seqan_add_cuda_executable (TARGET_NAME)
+# ---------------------------------------------------------------------------
+
+function (seqan_add_cuda_executable TARGET_NAME)
+    if (CUDA_FOUND)
+        # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
+
+        # -------------------------------------------------------------------
+        # Set CUDA variables
+        # -------------------------------------------------------------------
+        set (CUDA_PROPAGATE_HOST_FLAGS OFF)
+        set (CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE OFF)
+        #set (CUDA_NVCC_FLAGS "-pg")
+        list (APPEND CMAKE_CXX_SOURCE_FILE_EXTENSIONS "cu")
+        cuda_include_directories(${CUDA_CUT_INCLUDE_DIR})
+        #string (REGEX REPLACE "\\-(W( |all)|pedantic)" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
+        string (REGEX REPLACE "\\-pedantic" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
+
+        # -------------------------------------------------------------------
+        # Go on normally as in apps.
+        # -------------------------------------------------------------------
+        # message(STATUS "cuda_add_executable (${ARGV})")
+        cuda_add_executable (${ARGV})
+
+        add_dependencies(${SEQAN_CURRENT_APP_TARGET} ${ARGV0})
+
+        # Link against librt on Linux.
+      	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        	target_link_libraries (${TARGET_NAME} rt)
+      	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+      	# Dependencies on all registered seqan extensions.
+      	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
+
+        # -----------------------------------------------------------------------
+        # Instrumentation
+        # -----------------------------------------------------------------------
+	seqan_instrumentation_target(${ARGV0})
+
+      	# Link against zlib and bzlib if found.
+      	if (ZLIB_FOUND)
+      	    include_directories (${ZLIB_INCLUDE_DIR})
+      	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
+      	endif (ZLIB_FOUND)
+      	if (BZIP2_FOUND)
+      	    include_directories (${BZIP2_INCLUDE_DIR})
+      	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
+      	endif (BZIP2_FOUND)
+    endif (CUDA_FOUND)
+endfunction (seqan_add_cuda_executable TARGET_NAME)
+
+# ---------------------------------------------------------------------------
+# Function seqan_add_cuda_test_executable (TARGET_NAME source1.cu source2.[cu|cpp|h])
+#          seqan_add_cuda_test_executable (TARGET_NAME)
+# ---------------------------------------------------------------------------
+
+# Create a SeqAn CUDA executable from the given source files.  If no such
+# files are given then all files in the current directory will be used.
+#
+# Also the test will be registered with add_test and depend on the current
+# test target, i.e. from closest seqan_setup_tests(TEST_TARGET_NAME) call.
+#
+# Only adds target if CUDA_FOUND is set to true.
+
+function (seqan_add_cuda_test_executable TARGET_NAME)
+    if (CUDA_FOUND)
+        # TODO(holtgrew): Use all files in directory if ${ARGC} == 0
+
+        # -------------------------------------------------------------------
+        # Set CUDA variables
+        # -------------------------------------------------------------------
+        set (CUDA_PROPAGATE_HOST_FLAGS OFF)
+        set (CUDA_ATTACH_VS_BUILD_RULE_TO_CUDA_FILE OFF)
+        #set (CUDA_NVCC_FLAGS "-pg")
+        list (APPEND CMAKE_CXX_SOURCE_FILE_EXTENSIONS "cu")
+        cuda_include_directories(${CUDA_CUT_INCLUDE_DIR})
+        #string (REGEX REPLACE "\\-(W( |all)|pedantic)" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
+        string (REGEX REPLACE "\\-pedantic" "" CUDA_CXX_FLAGS ${CUDA_NVCC_FLAGS} ${CMAKE_CXX_FLAGS})
+
+        # -------------------------------------------------------------------
+        # Go on normally as in apps.
+        # -------------------------------------------------------------------
+        # message(STATUS "cuda_add_executable (${ARGV})")
+        cuda_add_executable (${ARGV})
+        add_test(test_${ARGV0} ${ARGV0})
+
+        add_dependencies(${SEQAN_CURRENT_TEST_TARGET} ${ARGV0})
+
+        # Link against librt on Linux.
+      	if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+        	target_link_libraries (${TARGET_NAME} rt)
+      	endif (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
+
+      	# Dependencies on all registered seqan extensions.
+      	add_dependencies(${ARGV0} ${SEQAN_LIBRARY_TARGETS})
+
+        # -----------------------------------------------------------------------
+        # Instrumentation
+        # -----------------------------------------------------------------------
+	seqan_instrumentation_target(${ARGV0})
+
+      	# Link against zlib and bzlib if found.
+      	if (ZLIB_FOUND)
+      	    include_directories (${ZLIB_INCLUDE_DIR})
+      	    target_link_libraries (${TARGET_NAME} ${ZLIB_LIBRARIES})
+      	endif (ZLIB_FOUND)
+      	if (BZIP2_FOUND)
+      	    include_directories (${BZIP2_INCLUDE_DIR})
+      	    target_link_libraries (${TARGET_NAME} ${BZIP2_LIBRARIES})
+      	endif (BZIP2_FOUND)
+    endif (CUDA_FOUND)
+endfunction (seqan_add_cuda_test_executable TARGET_NAME)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_add_all_executables ([TARGET])
+# ---------------------------------------------------------------------------
+
+# This macro calls seqan_add_executable() for all all .cpp files in the
+# current directory.  If the optional TARGET parameter is given, a target
+# with this name is created and the executable targets will depend on this
+# target.
+#
+# Example:
+#
+#   seqan_add_all_executables()
+#   seqan_add_all_executables(depend_on_this)
+#   seqan_add_all_executables(depend_on_this prefix)
+
+macro (seqan_add_all_executables)
+    file (GLOB ENTRIES
+          RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+          ${CMAKE_CURRENT_SOURCE_DIR}/[!.]*.cpp)
+    if (${ARGC} GREATER 1)
+        set (PREFIX ${ARGV1})
+    endif (${ARGC} GREATER 1)
+    if (${ARGC} GREATER 0)
+        if (TARGET ${ARGV0})  # Add target only if it does not exist yet.
+        else (TARGET ${ARGV0})
+            add_custom_target(${ARGV0})
+        endif (TARGET ${ARGV0})
+    endif (${ARGC} GREATER 0)
+    foreach (ENTRY ${ENTRIES})
+        get_filename_component(BIN_NAME ${ENTRY} NAME_WE)
+        seqan_add_executable(${PREFIX}${BIN_NAME} ${ENTRY})
+        if (${ARGC} GREATER 0)
+            add_dependencies(${ARGV0} ${PREFIX}${BIN_NAME})
+        endif (${ARGC} GREATER 0)
+    endforeach (ENTRY ${ENTRIES})
+endmacro (seqan_add_all_executables)
+
+# ---------------------------------------------------------------------------
+# Macro seqan_add_all_cuda_executables ([TARGET])
+# ---------------------------------------------------------------------------
+
+# This macro calls seqan_add_cuda_executable() for all all .cu files in the
+# current directory.  If the optional TARGET parameter is given, a target
+# with this name is created and the executable targets will depend on this
+# target.
+#
+# Only adds target if CUDA_FOUND is set to true.
+#
+# Example:
+#
+#   seqan_add_all_cuda_executables()
+#   seqan_add_all_cuda_executables(depend_on_this)
+
+macro (seqan_add_all_cuda_executables)
+    if (CUDA_FOUND)
+        file (GLOB ENTRIES
+              RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+              ${CMAKE_CURRENT_SOURCE_DIR}/*.cu)
+        if (${ARGC} GREATER 0)
+            if (TARGET ${ARGV0})  # Add target only if it does not exist yet.
+            else (TARGET ${ARGV0})
+                add_custom_target(${ARGV0})
+            endif (TARGET ${ARGV0})
+        endif (${ARGC} GREATER 0)
+        foreach (ENTRY ${ENTRIES})
+            get_filename_component(BIN_NAME ${ENTRY} NAME_WE)
+            # message("seqan_add_cuda_executable(${BIN_NAME} ${ENTRY})")
+            seqan_add_cuda_executable(${BIN_NAME} ${ENTRY})
+            if (${ARGC} GREATER 0)
+                add_dependencies(${ARGV0} ${BIN_NAME})
+            endif (${ARGC} GREATER 0)
+        endforeach (ENTRY ${ENTRIES})
+    endif (CUDA_FOUND)
+endmacro (seqan_add_all_cuda_executables)


Update Hunter: v0.12.23

Update Hunter: v0.12.23

--- common.cmake
+++ common.cmake
@@ -5,7 +5,7 @@
 # * https://github.com/ruslo/hunter
 include("${CMAKE_CURRENT_LIST_DIR}/cmake/HunterGate.cmake")
 HunterGate(
-    URL "https://github.com/ruslo/hunter/archive/v0.12.22.tar.gz"
-    SHA1 "868408f1f3d8deeaab13f4ebca28b02ec2dfcade"
+    URL "https://github.com/ruslo/hunter/archive/v0.12.23.tar.gz"
+    SHA1 "e1aad873adb4d0cd254c070f3e1a1c181d8daaea"
     ${CONFIG_FILE}
 )


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Modules/ThirdParty/KWSys/src/KWSys/kwsysDateStamp.cmake
+++ Modules/ThirdParty/KWSys/src/KWSys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 09)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   15)
+SET(KWSYS_DATE_STAMP_DAY   16)


Use CMake construct instead of '|grep' to determine emcc version. So that, the detection logic works on Windows host system too.

--- CMake/Toolchains/emscripten.toolchain.cmake
+++ CMake/Toolchains/emscripten.toolchain.cmake
@@ -42,9 +42,12 @@
     message (FATAL_ERROR "Could not find Emscripten cross compilation tool. "
         "Use EMSCRIPTEN_ROOT_PATH environment variable or build option to specify the location of the toolchain.")
 endif ()
-if (NOT EMCC_VERSION AND NOT CMAKE_HOST_WIN32)
-    execute_process (COMMAND ${EMSCRIPTEN_ROOT_PATH}/emcc --version COMMAND grep -oP \\d+\\.\\d+\\.\\d+ RESULT_VARIABLE EXIT_CODE OUTPUT_VARIABLE EMCC_VERSION ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
-    set (EMCC_VERSION ${EMCC_VERSION} CACHE STRING "emcc version on Unix-alike host system")
+if (NOT EMCC_VERSION)
+    execute_process (COMMAND ${EMSCRIPTEN_ROOT_PATH}/emcc --version RESULT_VARIABLE EXIT_CODE OUTPUT_VARIABLE EMCC_VERSION ERROR_QUIET OUTPUT_STRIP_TRAILING_WHITESPACE)
+    if (EXIT_CODE EQUAL 0)
+        string (REGEX MATCH "[^ .]+\\.[^.]+\\.[^ ]+" EMCC_VERSION ${EMCC_VERSION})
+    endif ()
+    set (EMCC_VERSION ${EMCC_VERSION} CACHE STRING "emcc version being used in this build tree")    # Cache the result even when there was error in determining the version
 endif ()
 if (CMAKE_HOST_WIN32)
     set (TOOL_EXT .bat)


From Torben Dannhauer, added freetype27 (2.7) to search list

--- CMakeModules/Find3rdPartyDependencies.cmake
+++ CMakeModules/Find3rdPartyDependencies.cmake
@@ -65,7 +65,7 @@

 MACRO(SEARCH_3RDPARTY OSG_3RDPARTY_BIN)
         FIND_DEPENDENCY(TIFF tiff.h libtiff ${OSG_3RDPARTY_BIN} "D" "_i")
-        FIND_DEPENDENCY(FREETYPE ft2build.h "freetype;freetype2311MT;freetype234;freetype234MT;freetype235;freetype237;freetype238;freetype244;freetype250;" ${OSG_3RDPARTY_BIN} "d" "")
+        FIND_DEPENDENCY(FREETYPE ft2build.h "freetype;freetype2311MT;freetype234;freetype234MT;freetype235;freetype237;freetype238;freetype244;freetype250;freetype27;" ${OSG_3RDPARTY_BIN} "d" "")
         IF(FREETYPE_FOUND)
             #forcing subsequent FindFreeType stuff to not search for other variables.... kind of a hack
             SET(FREETYPE_INCLUDE_DIR_ft2build ${FREETYPE_INCLUDE_DIR} CACHE PATH "" FORCE)


cmake: set CMAKE_CXX_FLAGS in FBCompilerSettingsUnix.cmake

Summary:
It looks like the various CMAKE_CXX_FLAGS_* are simply ineffective, and I'm not
sure why, setting CMAKE_CXX_FLAGS does work though, and CMake appears to add
some release/debug flags to it when generating Ninja files.

Reviewed By: fanzeyi

Differential Revision: D27862117

fbshipit-source-id: a89f6182b5bae9a087f8fcfd4c5f9526f91e2adf

--- build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake
+++ build/fbcode_builder/CMake/FBCompilerSettingsUnix.cmake
@@ -6,6 +6,4 @@
 # to these shared compiler settings in order to avoid accidentally
 # breaking a build in another project!

-set(CMAKE_CXX_FLAGS_COMMON "-g -Wall -Wextra -Wno-deprecated -Wno-deprecated-declarations")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} ${CMAKE_CXX_FLAGS_COMMON}")
-set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} ${CMAKE_CXX_FLAGS_COMMON} -O3")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -Wall -Wextra -Wno-deprecated -Wno-deprecated-declarations")


STYLE: Modern CMake style for itksoftwareguide-dashboard CTest script

--- Docker/itksoftwareguide-dashboard/dashboard.cmake
+++ Docker/itksoftwareguide-dashboard/dashboard.cmake
@@ -7,16 +7,16 @@
 #############################

 # Build identification.
-set( CTEST_SITE "$ENV{HOSTNAME}.docker" )
-set( CTEST_BUILD_NAME "Linux GCC Software Guide" )
-set( CTEST_BUILD_CONFIGURATION MinSizeRel )
-set( CTEST_CMAKE_GENERATOR "Ninja" )
+set(CTEST_SITE "$ENV{HOSTNAME}.docker")
+set(CTEST_BUILD_NAME "Linux GCC Software Guide")
+set(CTEST_BUILD_CONFIGURATION MinSizeRel)
+set(CTEST_CMAKE_GENERATOR "Ninja")

-set( CTEST_DASHBOARD_ROOT "/" )
-set( CTEST_SOURCE_DIRECTORY ${CTEST_DASHBOARD_ROOT}ITKSoftwareGuide )
-set( CTEST_BINARY_DIRECTORY ${CTEST_DASHBOARD_ROOT}ITKSoftwareGuide-build )
-set( CTEST_CONFIGURATION_TYPE ${CTEST_BUILD_CONFIGURATION} )
-set( CTEST_BUILD_FLAGS "-j5" )
+set(CTEST_DASHBOARD_ROOT "/")
+set(CTEST_SOURCE_DIRECTORY ${CTEST_DASHBOARD_ROOT}ITKSoftwareGuide)
+set(CTEST_BINARY_DIRECTORY ${CTEST_DASHBOARD_ROOT}ITKSoftwareGuide-build)
+set(CTEST_CONFIGURATION_TYPE ${CTEST_BUILD_CONFIGURATION})
+set(CTEST_BUILD_FLAGS "-j5")

 find_program(CTEST_GIT_COMMAND NAMES git git.cmd)
 if(NOT DEFINED CTEST_GIT_COMMAND)
@@ -24,32 +24,32 @@
 endif()

 # Upload information
-set( CTEST_NIGHTLY_START_TIME "01:00:00 UTC" )
-set( CTEST_DROP_METHOD "http" )
-set( CTEST_DROP_SITE "open.cdash.org" )
-set( CTEST_DROP_LOCATION "/submit.php?project=Insight" )
-set( CTEST_DROP_SITE_CDASH TRUE )
-list( APPEND CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}" )
+set(CTEST_NIGHTLY_START_TIME "01:00:00 UTC")
+set(CTEST_DROP_METHOD "http")
+set(CTEST_DROP_SITE "open.cdash.org")
+set(CTEST_DROP_LOCATION "/submit.php?project=Insight")
+set(CTEST_DROP_SITE_CDASH TRUE)
+list(APPEND CTEST_NOTES_FILES "${CTEST_SCRIPT_DIRECTORY}/${CTEST_SCRIPT_NAME}")

 # Start with a fresh build tree.
-ctest_empty_binary_directory( ${CTEST_BINARY_DIRECTORY}/ )
+ctest_empty_binary_directory(${CTEST_BINARY_DIRECTORY}/)

 # Initial cache.
-file( WRITE ${CTEST_BINARY_DIRECTORY}/CMakeCache.txt "
+file(WRITE ${CTEST_BINARY_DIRECTORY}/CMakeCache.txt "
 SITE:STRING=${CTEST_SITE}
 BUILDNAME:STRING=${CTEST_BUILD_NAME}
 ITK_GIT_TAG:STRING=nightly-master
-" )
+")

-ctest_start( Nightly )
+ctest_start(Nightly)
 ctest_update()
-ctest_configure( BUILD "${CTEST_BINARY_DIRECTORY}" SOURCE "${CTEST_SOURCE_DIRECTORY}" )
-ctest_submit( PARTS Update Notes Configure )
+ctest_configure(BUILD "${CTEST_BINARY_DIRECTORY}" SOURCE "${CTEST_SOURCE_DIRECTORY}")
+ctest_submit(PARTS Update Notes Configure)

-ctest_build( BUILD "${CTEST_BINARY_DIRECTORY}" APPEND )
-ctest_test( BUILD "${CTEST_BINARY_DIRECTORY}" )
-ctest_submit( PARTS Build Test )
+ctest_build(BUILD "${CTEST_BINARY_DIRECTORY}" APPEND)
+ctest_test(BUILD "${CTEST_BINARY_DIRECTORY}")
+ctest_submit(PARTS Build Test)

-file( GLOB pdfs "${CTEST_BINARY_DIRECTORY}/ITKSoftwareGuide-build/SoftwareGuide/Latex/*.pdf" )
-ctest_upload( FILES ${pdfs} )
-ctest_submit( PARTS Upload )
+file(GLOB pdfs "${CTEST_BINARY_DIRECTORY}/ITKSoftwareGuide-build/SoftwareGuide/Latex/*.pdf")
+ctest_upload(FILES ${pdfs})
+ctest_submit(PARTS Upload)


coorect name for boost random

coorect name for boost random

--- boost.cmake
+++ boost.cmake
@@ -34,7 +34,7 @@
     UPDATE_COMMAND      ""
     PATCH_COMMAND       ""
     CONFIGURE_COMMAND   ${BUILDEM_ENV_STRING} ./bootstrap.sh
-        --with-libraries=date_time,filesystem,python,regex,serialization,system,test,thread,program_options,boost_random
+        --with-libraries=date_time,filesystem,python,regex,serialization,system,test,thread,program_options,random
         --with-python=${PYTHON_EXE}
         --prefix=${BUILDEM_DIR}
         LDFLAGS=${BUILDEM_LDFLAGS}


build examples in readme

build examples in readme

--- plugin_loader.cmake
+++ plugin_loader.cmake
@@ -1,9 +0,0 @@
-hg_clone(https://bitbucket.org/ww/goautoneg default)
-git_clone(https://github.com/prometheus/client_golang master)
-git_clone(https://github.com/prometheus/procfs master)
-git_clone(http://github.com/matttproud/golang_protobuf_extensions master)
-git_clone(http://github.com/golang/protobuf master)
-git_clone(https://github.com/prometheus/client_model master)
-git_clone(http://github.com/beorn7/perks master)
-
-add_external_plugin(git https://github.com/davidbirdsong/heka-promethus master)


Port the variadic std::tr1::tuple hack for building gtest for MSVC2012 to ASAN tests.

Summary: This is copied from llvm/utils/unittest/CMakeLists.txt.

Test Plan: This partly enables building ASAN tests with MSVC2012.

Reviewers: timurrrr

Subscribers: llvm-commits

Differential Revision: http://reviews.llvm.org/D5342

git-svn-id: c199f293c43da69278bea8e88f92242bf3aa95f7@217762 91177308-0d34-0410-b5e6-96231b3b80d8

--- cmake/Modules/AddCompilerRT.cmake
+++ cmake/Modules/AddCompilerRT.cmake
@@ -138,6 +138,12 @@

   # gtest use a lot of stuff marked as deprecated on Windows.
   list(APPEND COMPILER_RT_GTEST_CFLAGS -Wno-deprecated-declarations)
+
+  # Visual Studio 2012 only supports up to 8 template parameters in
+  # std::tr1::tuple by default, but gtest requires 10
+  if(MSVC_VERSION EQUAL 1700)
+    add_definitions(-D_VARIADIC_MAX=10)
+  endif()
 endif()

 # Link objects into a single executable with COMPILER_RT_TEST_COMPILER,


Add search paths for cassandra cpp-driver library.

--- cmake/modules/FindCassandra.cmake
+++ cmake/modules/FindCassandra.cmake
@@ -24,7 +24,7 @@
 find_library(Cassandra_LIBRARY
   NAMES cassandra libcassandra
   HINTS ${_CASS_ROOT_PATHS}
-  PATH_SUFFIXES lib lib64)
+  PATH_SUFFIXES lib lib64 "bin/${CMAKE_CXX_COMPILER_ID}/${CMAKE_BUILD_TYPE}" "build/${CMAKE_CXX_COMPILER_ID}/${CMAKE_BUILD_TYPE}")
 find_package_handle_standard_args(Cassandra "Could NOT find cassandra, try to set the path to the cassandra root folder in the system variable Cassandra_ROOT_DIR"
     Cassandra_LIBRARY
     Cassandra_INCLUDE_DIR)


Removed unnecesary dependencies from ROOT's object files.

THe object files of the ROOT libraries currently depend on the
dictionary generation because CMake inherits the add_library
dependencies just for good measure. To speed up (re-)compilation,
we remove this dependency by compiling everything first into
a CMake OBJECT library and then link against those object files,
prevent CMake from adding those extra dependencies.

--- cmake/modules/RootNewMacros.cmake
+++ cmake/modules/RootNewMacros.cmake
@@ -580,11 +580,43 @@
                        DEPENDS bindexplib )
   else()
     #---Need to add a dummy source file if all sources are OBJECT libraries (Xcode, ...)
-    if(NOT lib_srcs MATCHES "(^|[;])[^$][^<]")
-      add_custom_command(OUTPUT dummy.cxx COMMAND ${CMAKE_COMMAND} -E touch dummy.cxx)
-      set(lib_srcs ${lib_srcs} dummy.cxx)
-    endif()
-    add_library( ${library} ${_all} ${ARG_TYPE} ${lib_srcs})
+    add_custom_command(OUTPUT dummy.cxx COMMAND ${CMAKE_COMMAND} -E touch dummy.cxx)
+    # We have two possible kind of inputs to this function. One are real source files
+    # like headers and source file and the others are object files that we don't need
+    # to compile. We now assign each source file into one of those groups.
+    # The motivation behind this is that we don't want to just use add_library() on all
+    # passed source files because then they all have the same dependencies as our library
+    # linking target (which is a safety measure by CMake). E.g. if we just call add_library
+    # on the input set, then the compilation of each .o files would depend on the rootcling
+    # invocation of this dictionary (which in turns depends on a lot of expensive targets
+    # like LLVM and clang ) even though we don't need any of those just for compiling our
+    # object files.
+    # So what we do below is taking all our 'real source files' that need to be compiled and
+    # compile them first into an CMake "Object library" (aka, just compiling them into
+    # object files) which has no unnecesary dependencies beside move_headers. Then we
+    # reference those object files from the final add_library call. Now those object files
+    # can be compiled in parallel to the rootcling/LLVM/clang path and are only blocking
+    # the compilation when we hit the linking step for the current library.
+    foreach(source_file ${lib_srcs})
+      if (source_file)
+        if("${source_file}" MATCHES "[.](o)$" OR "${source_file}" MATCHES "[$][<]" OR "${source_file}" MATCHES "^G__")
+            set(obj_sources "${obj_sources};${source_file}")
+        elseif ("${source_file}" MATCHES "[.](cc|cpp|cxx|hh|hpp|hxx|h|c|mm)$")
+            set(real_sources "${real_sources};${source_file}")
+        else()
+            message(AUTHOR_WARNING "Unknown file type: '${source_file}'")
+            # Let's add it to object sources which is the old way of handling this.
+            set(obj_sources "${obj_sources};${source_file}")
+        endif()
+      endif()
+    endforeach()
+    if (real_sources)
+      add_library(${library}_OBJS OBJECT ${real_sources})
+      add_dependencies(${library}_OBJS move_headers)
+      set(${library}_OBJS_LIST $<TARGET_OBJECTS:${library}_OBJS>)
+    endif()
+
+    add_library(${library} ${_all} ${ARG_TYPE} ${obj_sources} ${${library}_OBJS_LIST} dummy.cxx)
     if(ARG_TYPE STREQUAL SHARED)
       set_target_properties(${library} PROPERTIES  ${ROOT_LIBRARY_PROPERTIES} )
     endif()


Change the INCLUDE path for gemmlowp (#1066)

Remove '..' from INCLUDE PATH.

--- cmake/onnxruntime_providers.cmake
+++ cmake/onnxruntime_providers.cmake
@@ -46,7 +46,7 @@
 endif()

 onnxruntime_add_include_to_target(onnxruntime_providers onnxruntime_common onnxruntime_framework gsl onnx onnx_proto protobuf::libprotobuf)
-set(gemmlowp_src ${ONNXRUNTIME_ROOT}/../cmake/external/gemmlowp)
+set(gemmlowp_src ${PROJECT_SOURCE_DIR}/external/gemmlowp)
 set(re2_src ${ONNXRUNTIME_ROOT}/../cmake/external/re2)
 target_include_directories(onnxruntime_providers PRIVATE ${ONNXRUNTIME_ROOT} ${eigen_INCLUDE_DIRS} ${gemmlowp_src} ${re2_src})
 add_dependencies(onnxruntime_providers gsl onnx ${onnxruntime_EXTERNAL_DEPENDENCIES})


Added additional lib search paths to help Windows locate the right directory (#44)

--- cmakemodule/FindSuiteSparse.cmake
+++ cmakemodule/FindSuiteSparse.cmake
@@ -90,6 +90,8 @@
 	endif()
 endif()

+## get CMAKE_INSTALL_BINDIR and CMAKE_INSTALL_LIBDIR
+include(GNUInstallDirs)

 ## This utility macro is used to find all suitesparse projects by giving its name
 ## Since the name structure is the same for lib name and include dir name,
@@ -176,6 +178,11 @@
 							${SuiteSparse_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 							${${suitesparseCompUC}_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 							${${suitesparseCompUC}_DIR}
+							/opt/local/${CMAKE_INSTALL_LIBDIR}
+							/usr/${CMAKE_INSTALL_LIBDIR}
+							/usr/local/${CMAKE_INSTALL_LIBDIR}
+							${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}
+							${${suitesparseCompUC}_DIR}/${CMAKE_INSTALL_LIBDIR}
 			PATH_SUFFIXES	Release
 		)
 		find_library(SuiteSparse_${suitesparseCompUC}_LIBRARY_DEBUG
@@ -187,6 +194,11 @@
 							${SuiteSparse_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 							${${suitesparseCompUC}_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 							${${suitesparseCompUC}_DIR}
+							/opt/local/${CMAKE_INSTALL_LIBDIR}
+							/usr/${CMAKE_INSTALL_LIBDIR}
+							/usr/local/${CMAKE_INSTALL_LIBDIR}
+							${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}
+							${${suitesparseCompUC}_DIR}/${CMAKE_INSTALL_LIBDIR}
 			PATH_SUFFIXES	Debug
 		)

@@ -290,6 +302,13 @@
 		${SuiteSparse_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}/lapack_blas_windows
 		${SuiteSparse_DIR}/lapack_blas_windows
 		${SuiteSparse_DIR}/lapack_blas_windows/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
+		${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}
+		${SuiteSparse_DIR}/lapack_windows/${CMAKE_INSTALL_LIBDIR}
+		${SuiteSparse_DIR}/blas_windows/${CMAKE_INSTALL_LIBDIR}
+		${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}/lapack_windows
+		${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}/blas_windows
+		${SuiteSparse_DIR}/${CMAKE_INSTALL_LIBDIR}/lapack_blas_windows
+		${SuiteSparse_DIR}/lapack_blas_windows/${CMAKE_INSTALL_LIBDIR}
 	)

 	## try to find blas lib
@@ -301,6 +320,11 @@
 						${SuiteSparse_BLAS_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 						${SuiteSparse_BLAS_DIR}
 						${ADDITIONAL_SEARCH_DIRS}
+						/opt/local/${CMAKE_INSTALL_LIBDIR}
+						/usr/${CMAKE_INSTALL_LIBDIR}
+						/usr/local/${CMAKE_INSTALL_LIBDIR}
+						${SuiteSparse_BLAS_DIR}/${CMAKE_INSTALL_LIBDIR}
+						$
 		PATH_SUFFIXES	Release Debug
 	)
 	if(NOT SuiteSparse_BLAS_LIBRARY)
@@ -325,6 +349,10 @@
 						${SuiteSparse_LAPACK_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
 						${SuiteSparse_LAPACK_DIR}
 						${ADDITIONAL_SEARCH_DIRS}
+						/opt/local/${CMAKE_INSTALL_LIBDIR}
+						/usr/${CMAKE_INSTALL_LIBDIR}
+						/usr/local/${CMAKE_INSTALL_LIBDIR}
+						${SuiteSparse_LAPACK_DIR}/${CMAKE_INSTALL_LIBDIR}
 		PATH_SUFFIXES	Release Debug
 	)
 	if(NOT SuiteSparse_LAPACK_LIBRARY)
@@ -370,7 +398,7 @@
 			${SuiteSparse_LAPACK_DIR}/bin/${SuiteSparse_SEARCH_BIN_POSTFIX_2}
 			${SuiteSparse_LAPACK_DIR}/bin/Release/${SuiteSparse_SEARCH_BIN_POSTFIX_1}
 			${SuiteSparse_LAPACK_DIR}/bin/Debug/${SuiteSparse_SEARCH_BIN_POSTFIX_2}
-			${SuiteSparse_LAPACK_DIR}/lib${SuiteSparse_SEARCH_LIB_POSTFIX}
+			${SuiteSparse_LAPACK_DIR}/${CMAKE_INSTALL_LIBDIR}
 			${SuiteSparse_BLAS_DIR}
 			${SuiteSparse_BLAS_DIR}/bin
 			${SuiteSparse_BLAS_DIR}/bin/${SuiteSparse_SEARCH_BIN_POSTFIX_1}


Added correct PMD lib and OpenCV lib to search library path.

--- CMake/mitkFunctionGetLibrarySearchPaths.cmake
+++ CMake/mitkFunctionGetLibrarySearchPaths.cmake
@@ -54,10 +54,16 @@
     if(DCMTK_DIR)
       list(APPEND _dir_candidates "${DCMTK_DIR}/bin")
     endif()
+    if(OpenCV_DIR)
+      list(APPEND _dir_candidates "${OpenCV_DIR}/bin")
+    endif()
     list(APPEND _dir_candidates "${ITK_DIR}/bin")
   else()
     if(DCMTK_DIR)
       list(APPEND _dir_candidates "${DCMTK_DIR}/lib")
+    endif()
+    if(OpenCV_DIR)
+      list(APPEND _dir_candidates "${OpenCV_DIR}/lib")
     endif()
     list(APPEND _dir_candidates "${ITK_DIR}/lib")
   endif()
@@ -89,9 +95,6 @@
   if(tinyxml_DIR)
     list(APPEND _dir_candidates "${tinyxml_DIR}")
   endif()
-  if(OpenCV_DIR)
-    list(APPEND _dir_candidates "${OpenCV_DIR}/bin")
-  endif()
   if(Poco_DIR)
     list(APPEND _dir_candidates "${Poco_DIR}/lib")
   endif()
@@ -105,7 +108,7 @@
     list(APPEND _dir_candidates "${SOFA_DIR}/bin")
   endif()
   if(MITK_USE_TOF_PMDO3 OR MITK_USE_TOF_PMDCAMCUBE OR MITK_USE_TOF_PMDCAMBOARD)
-    list(APPEND _dir_candidates "${MITK_PMD_SDK_DIR}/plugins")
+    list(APPEND _dir_candidates "${MITK_PMD_SDK_DIR}/plugins" "${MITK_PMD_SDK_DIR}/bin")
   endif()

   if(MITK_USE_CTK)


CI: some debug info

CI: some debug info

--- CI/main_ci.cmake
+++ CI/main_ci.cmake
@@ -49,6 +49,7 @@

 message(STATUS "CI profile : $ENV{OTB_CI_PROFILE}")
 message(STATUS "CI_COMMIT_REF_NAME : $ENV{CI_COMMIT_REF_NAME}")
+message(STATUS "CTEST_BUILD_NAME : ${CTEST_BUILD_NAME}")

 #The following file set the CONFIGURE_OPTIONS variable
 set (CONFIGURE_OPTIONS  "")


BUG: mantis 1325 - update libsvm url (switch to github archive)

--- SuperBuild/CMake/External_libsvm.cmake
+++ SuperBuild/CMake/External_libsvm.cmake
@@ -4,8 +4,8 @@

 ExternalProject_Add(LIBSVM
   PREFIX LIBSVM
-  URL "http://www.csie.ntu.edu.tw/~cjlin/libsvm/libsvm-3.20.tar.gz"
-  URL_MD5 5f088e5f89da1c65b642300c9c5ea772
+  URL "https://github.com/cjlin1/libsvm/archive/v320.tar.gz"
+  URL_MD5 b735fce96fc634f1d7e26b586181e1a4
   BINARY_DIR ${LIBSVM_SB_BUILD_DIR}
   DOWNLOAD_DIR ${DOWNLOAD_LOCATION}
   INSTALL_DIR ${SB_INSTALL_PREFIX}


SuperBuild: fix geos build

SuperBuild: fix geos build

--- SuperBuild/CMake/External_geos.cmake
+++ SuperBuild/CMake/External_geos.cmake
@@ -21,7 +21,6 @@
   INSTALL_DIR ${SB_INSTALL_PREFIX}
   DOWNLOAD_DIR ${DOWNLOAD_LOCATION}
   CMAKE_CACHE_ARGS
-  -DProject_WC_REVISION:STRING=99999
   -DBUILD_TESTING:BOOL=OFF
   -DGEOS_ENABLE_TESTS:BOOL=OFF
   CMAKE_COMMAND ${SB_CMAKE_COMMAND} )


SuperBuild: remove zlib static from install tree

--- SuperBuild/CMake/External_zlib.cmake
+++ SuperBuild/CMake/External_zlib.cmake
@@ -31,14 +31,18 @@
       -DCMAKE_BUILD_TYPE:STRING=Release
       #-DCMAKE_CXX_COMPILER:FILEPATH=${CMAKE_CXX_COMPILER}
       #-DCMAKE_C_COMPILER:FILEPATH=${CMAKE_C_COMPILER}
-      -DBUILD_SHARED_LIBS:BOOL=ON
-  )
+      -DBUILD_SHARED_LIBS:BOOL=ON)
+
+    if(UNIX)
+      ExternalProject_Add_Step(${proj} remove_static
+        COMMAND ${CMAKE_COMMAND} -E remove ${SB_INSTALL_PREFIX}/lib/libz.a
+        DEPENDEES install)
+    endif()

     if(MSVC)
       ExternalProject_Add_Step(${proj} msvc_copy_hell
         COMMAND ${CMAKE_COMMAND} -E copy ${ZLIB_SB_BUILD_DIR}/zlib.lib ${SB_INSTALL_PREFIX}/lib/zdll.lib
-        DEPENDEES install
-      )
+        DEPENDEES install)
     endif()

     set(_SB_${proj}_INCLUDE_DIR ${SB_INSTALL_PREFIX}/include)


Install python packages via pip first

Install python packages via pip first

--- scripts/PythonPackageLookup.cmake
+++ scripts/PythonPackageLookup.cmake
@@ -59,6 +59,8 @@
         return()
     endif()

+    get_filename_component(lpp_PATH "${lpp_PATH}" ABSOLUTE)
+    get_filename_component(EXTERNAL_ROOT "${EXTERNAL_ROOT}" ABSOLUTE)
     if(NOT EXISTS "${lpp_PATH}")
         file(MAKE_DIRECTORY "${lpp_PATH}")
     endif()
@@ -73,9 +75,16 @@
         "    environ['PYTHONPATH'] += ':${lpp_PATH}'\n"
         "from sys import path, exit\n"
         "path.append('${lpp_PATH}')\n"
-        "from setuptools.command.easy_install import main as install\n"
-        "result = install(['--install-dir', path[-1], '${package}'])\n"
-        "exit(0 if result == True else 1)\n"
+        "try:\n"
+        "    from pip import main as install\n"
+        "    args = ['install', '--target', path[-1], '${package}']\n"
+        "    result = install(args)\n"
+        "    exit(result)\n"
+        "except ImportError:\n"
+        "    from setuptools.command.easy_install import main as install\n"
+        "    args = ['--install-dir', path[-1], '${package}']\n"
+        "    result = install(args)\n"
+        "    exit(0 if result == True else 1)\n"
     )
     execute_process(
         COMMAND ${LOCALPYTHON} "${EXTERNAL_ROOT}/install_${package}.py"
@@ -83,8 +92,16 @@
         ERROR_VARIABLE error
         OUTPUT_VARIABLE output
     )
-    if(lpp_REQUIRED)
-        set(arguments "${arguments} REQUIRED")
+    if(result EQUAL 0)
+        if(lpp_REQUIRED)
+            set(arguments "${arguments} REQUIRED")
+        endif()
+        find_python_package(${package} ${arguments} ${lpp_UNPARSED_ARGUMENTS})
+    elseif(lpp_REQUIRED)
+        message("output: ${output}\n")
+        message("error: ${error}\n")
+        message(FATAL_ERROR "Could not install ${package}")
+    else()
+        message(WARNING "Could not install ${package}")
     endif()
-    find_python_package(${package} REQUIRED ${lpp_UNPARSED_ARGUMENTS})
 endfunction()


Refactor FindCouchbaseLibuv

Refactor FindCouchbaseLibuv

This removes some older cruft and makes custom paths function properly
even when a system-provided libuv is available.

Change-Id: I277fd9ea5a8966c12f63f3f64661788cb62f51c3
Reviewed-on: http://review.couchbase.org/46745
Tested-by: Mark Nunberg <dab05a0fe859c5cb93882b2a75a0d613501b07be@couchbase.com>
Reviewed-by: Brett Lawson <c8c4369773d7d7226e031f0c4af62e3f38a08510@gmail.com>

--- cmake/Modules/FindCouchbaseLibuv.cmake
+++ cmake/Modules/FindCouchbaseLibuv.cmake
@@ -5,46 +5,38 @@
 #  LIBUV_INCLUDE_DIR, where to find the ICU headers

 FIND_PATH(LIBUV_INCLUDE_DIR uv.h
-          HINTS
-               ENV LIBUV_DIR
+          HINTS ${LIBUV_ROOT}
           PATH_SUFFIXES include
           PATHS
-               ${LIBUV_ROOT}
-               ${DEPS_INCLUDE_DIR}
                ~/Library/Frameworks
                /Library/Frameworks
                /opt/local
                /opt/csw
                /opt/libuv
                /opt)
+MESSAGE(STATUS "Found UV include dir: ${LIBUV_INCLUDE_DIR}")

 IF(WIN32)
     FIND_LIBRARY(LIBUV_LIBRARIES_DEBUG
         NAMES uv libuv
-        HINTS ENV LIBUV_DIR
-        PATH_SUFFIXES Debug Debug/lib
-        PATHS ${LIBUV_ROOT})
+        HINTS ${LIBUV_ROOT}
+        PATH_SUFFIXES Debug Debug/lib)

     FIND_LIBRARY(LIBUV_LIBRARIES_OPTIMIZED
         NAMES uv libuv
-        HINTS ENV LIBUV_DIR
-        PATH_SUFFIXES Release Release/lib
-        PATHS ${LIBUV_ROOT})
+        HINTS ${LIBUV_ROOT}
+        PATH_SUFFIXES Release Release/lib)

     SET(LIBUV_LIBRARIES
-        optimized
-            ${LIBUV_LIBRARIES_OPTIMIZED}
-        debug
-            ${LIBUV_LIBRARIES_DEBUG})
+        OPTIMIZED ${LIBUV_LIBRARIES_OPTIMIZED}
+        DEBUG ${LIBUV_LIBRARIES_DEBUG})

 ELSE()
     FIND_LIBRARY(LIBUV_LIBRARIES
         NAMES uv
-        HINTS
-            ENV LIBUV_DIR
+        HINTS ${LIBUV_ROOT}
+        PATH_SUFFIXES lib
         PATHS
-            ${LIBUV_ROOT}
-            ${DEPS_LIB_DIR}
             ~/Library/Frameworks
             /Library/Frameworks
             /opt/local


Code cleanup, removed redundant check as now Urho3D library build type is mutually exclusive of Urho3D executable build.

--- cmake/Modules/Urho3D-CMake-magic.cmake
+++ cmake/Modules/Urho3D-CMake-magic.cmake
@@ -248,7 +248,7 @@
     add_library (${TARGET_NAME} ${LIB_TYPE} ${SOURCE_FILES})
     setup_target ()

-    if (CMAKE_PROJECT_NAME STREQUAL Urho3D AND NOT LIB_TYPE STREQUAL SHARED AND NOT TARGET_NAME MATCHES "Urho3D|Assimp")   # Exclude Assimp explicitly here just to be safe though Assimp does not use this macro
+    if (CMAKE_PROJECT_NAME STREQUAL Urho3D AND NOT LIB_TYPE STREQUAL SHARED)
         set (STATIC_LIBRARY_TARGETS ${STATIC_LIBRARY_TARGETS} ${TARGET_NAME} PARENT_SCOPE)
         if (URHO3D_BUILD_TYPE STREQUAL SHARED)
             set_target_properties (${TARGET_NAME} PROPERTIES COMPILE_DEFINITIONS URHO3D_EXPORTS)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 12)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   05)
+SET(KWSYS_DATE_STAMP_DAY   06)


STYLE: Nightly Date Stamp

STYLE: Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -7,4 +7,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 07)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   01)
+SET(KWSYS_DATE_STAMP_DAY   02)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -15,7 +15,7 @@
 SET(KWSYS_DATE_STAMP_YEAR  2012)

 # KWSys version date month component.  Format is MM.
-SET(KWSYS_DATE_STAMP_MONTH 01)
+SET(KWSYS_DATE_STAMP_MONTH 02)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   31)
+SET(KWSYS_DATE_STAMP_DAY   01)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 12)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   17)
+SET(KWSYS_DATE_STAMP_DAY   18)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 10)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   30)
+SET(KWSYS_DATE_STAMP_DAY   31)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 06)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   11)
+SET(KWSYS_DATE_STAMP_DAY   12)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 09)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   16)
+SET(KWSYS_DATE_STAMP_DAY   17)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 01)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   03)
+SET(KWSYS_DATE_STAMP_DAY   04)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 01)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   29)
+SET(KWSYS_DATE_STAMP_DAY   30)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 12)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   28)
+SET(KWSYS_DATE_STAMP_DAY   29)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 01)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   18)
+SET(KWSYS_DATE_STAMP_DAY   19)


STYLE: Nightly Date Stamp

STYLE: Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -7,4 +7,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 10)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   28)
+SET(KWSYS_DATE_STAMP_DAY   29)


STYLE: Nightly Date Stamp

STYLE: Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -4,7 +4,7 @@
 SET(KWSYS_DATE_STAMP_YEAR  2009)

 # KWSys version date month component.  Format is MM.
-SET(KWSYS_DATE_STAMP_MONTH 04)
+SET(KWSYS_DATE_STAMP_MONTH 05)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   30)
+SET(KWSYS_DATE_STAMP_DAY   01)


KWSys Nightly Date Stamp

KWSys Nightly Date Stamp

--- Utilities/kwsys/kwsysDateStamp.cmake
+++ Utilities/kwsys/kwsysDateStamp.cmake
@@ -18,4 +18,4 @@
 SET(KWSYS_DATE_STAMP_MONTH 05)

 # KWSys version date day component.  Format is DD.
-SET(KWSYS_DATE_STAMP_DAY   09)
+SET(KWSYS_DATE_STAMP_DAY   10)


hunter_add_package: add assert

hunter_add_package: add assert

--- cmake/modules/hunter_add_package.cmake
+++ cmake/modules/hunter_add_package.cmake
@@ -5,6 +5,7 @@

 include(hunter_internal_error)
 include(hunter_status_debug)
+include(hunter_test_string_not_empty)

 # internal variables: _hunter_ap_*
 macro(hunter_add_package)
@@ -20,6 +21,7 @@
   endif()
   list(GET _hunter_ap_arg_UNPARSED_ARGUMENTS 0 _hunter_ap_project)

+  hunter_test_string_not_empty("${HUNTER_SELF}")
   set(
       _hunter_ap_project_dir
       "${HUNTER_SELF}/cmake/projects/${_hunter_ap_project}"


Remove version diff from logs

Remove version diff from logs

--- cmake/modules/hunter_add_version.cmake
+++ cmake/modules/hunter_add_version.cmake
@@ -47,9 +47,6 @@
   endif()
   string(COMPARE NOTEQUAL "${${expected_version}}" "${h_VERSION}" version_diff)
   if(version_diff)
-    hunter_status_debug(
-        "Skip '${h_VERSION}' (looking for '${${expected_version}}')"
-    )
     return()
   endif()