ANNOUNCE

 ANNOUNCEMENT
 
-Version 3.6.3 of the OFFIS DCMTK (DICOM ToolKit) software is now available for
+Version 3.6.4 of the OFFIS DCMTK (DICOM ToolKit) software is now available for
 public release.  This is a minor release that includes the following changes
-over the previous version 3.6.2:
+over the previous version 3.6.3:
 
-- DCMTK 3.6.3 builds correctly on older and up-to-date versions of GNU gcc
-  (4.2.1 to 7.1.1) Clang (3.4.1 to 4.0.1),  Microsoft Visual Studio (2005 to
+- DCMTK 3.6.4 builds correctly on older and up-to-date versions of GNU gcc
+  (4.2.1 to 8.2.1) Clang (3.4.2 to 7.0.0),  Microsoft Visual Studio (2005 to
   2017) and SunPro CC (5.14 and 5.15).
 
 - Tested with the following operating systems/environments:
@@ -23,81 +23,128 @@ over the previous version 3.6.2:
 
   For a complete list of tested systems and compilers, see the INSTALL file.
 
-- GNU Autoconf has been deprecated, running 'configure' will now emit a
-  warning by default.
+- GNU Autoconf is still deprecated, running 'configure' emits a warning by
+  default.  Support for GNU Autoconf will be removed after this release.
 
 - Updated data dictionary, SOP Class and Transfer Syntax UIDs for the recently
   approved changes to the DICOM standard (i.e. Supplements and CPs), up to DICOM
-  standard release DICOM 2017e.
+  standard release DICOM 2018d plus Supplement 188 (Multi-energy CT Images),
+  CP-1803 and CP-1809.
 
-- Updated automatically generated classes in module "dcmrt" (Radiotherapy) and
-  "dcmsr" (Structured Reporting) based on DICOM 2017e.  Also updated the Code
+- Added "dcmicmp", a new tool that reads two DICOM images, an original
+  "reference image" and a post-processed "test image" to which some kind of
+  processing such as a lossy image compression has been applied.  dcmicmp
+  compares both images and computes several metrics that describe how similar
+  or different both images are.
+
+- Added new command line applications: cda2dcm and stl2dcm for encapsulation
+  of HL7 CDA documents and STL files into DICOM file format.  Revised
+  implementation of pdf2dcm based on new class DcmEncapsulatedDocument.
+
+- The lossless JPEG decoder can now handle images compressed with the
+  Cornell codec, which creates invalid Huffman codes for 16-bit images.
+
+- The new class OFRandom implements a cryptographically secure pseudo
+  random number generator (PRNG) based on the ISAAC algorithm and its public
+  domain reference implementation by Bob Jenkins.
+
+- Major revision of the TLS code in DCMTK (module dcmtls and related command
+  line tools) implementing DICOM Supplement 204 "TLS Security Profiles".
+  Selection of TLS ciphersuites is now based on security profiles, and
+  DCMTK now implements the recommendations of BCP 195 / RFC 7525.
+
+- DCMTK can now be compiled with LibreSSL as an alternative to OpenSSL.
+
+- Updated automatically generated Context Group classes in "dcmsr"
+  (Structured Reporting) based on DICOM 2018d.  Also updated the Code
   definitions from the supported coding schemes such as DICOM, NCIt and UMLS.
 
 - Further enhanced DICOM Structured Reporting (SR) module "dcmsr":
 
-  - Added support for the Patient Radiation Dose SR IOD (Supplement 191).
+  - Added support for included template TID 4019 (Algorithm Identification) to
+    the implementation of TID 1419 (ROI Measurements).
 
-  - Added support for further sub-templates to the existing class for TID 1500
-    (Measurement Report), e.g. TID 300 (Measurement).
+  - Added a document tree node filter that checks for the presence or absence
+    of a concept name, i.e. whether it is empty or not.
 
-  - Enhanced support for image entry descriptors in TID 1600 (Image Library),
-    e.g. by adding a new method that allows for moving common image entry
-    descriptors automatically to their respective image group.
+  - Added new and enhanced existing code examples for this module.
 
-  - Added new method that allows for adding extra content items to extensible
-    SR templates.
+- Enhanced Worklist SCP code to make use of existing classes and functions
+  instead of using its own "spaghetti" code for everything.  This also
+  resolves issues with the Worklist SCP rejecting some legit Worklist queries
+  as its own verification functions were too strict.
 
-  - Further enhanced iterating an SR document tree, e.g. by providing a new
-    filter mechanism that allows for matching document tree nodes based on a
-    variety of properties like value type and concept name.
+- Added method getNumberOfValues() to all VR and other classes that are
+  derived from DcmObject (such as DcmItem).  This new method always returns
+  the number of values currently stored in the corresponding object/element,
+  in contrast to getVM(), which sometimes returns the constant 1, or card(),
+  which is not available for all classes.
 
-  - Added another gotoNode() method to tree and cursor class, which searches for
-    a particular tree node by its value.
+- The ACSE timeout, e.g. passed to the various networking command line tools
+  using --acse-timeout, is now also used for the first PDU to be read.  This is
+  another step towards cleaning up the timeout handling in dcmnet module.
 
-  - Added "equal" and "not equal" comparison operators to all document tree node
-    and underlying value classes as well as to the wrapper class for "SR content
-    items".
+- Replaced all calls of strcpy() by OFStandard::strlcpy(), which should reduce
+  the possibility of buffer overflows.  Also added OFStandard::snprintf() and
+  OFStandard::vsnprintf(), which should be used within the DCMTK as safe and
+  portable helper functions.
 
-  - Updated mapping of the Defined Terms for Body Part Examined in the class
-    that implements CID 4031 (Common Anatomic Regions) based on DICOM 2017e.
+- Fixed bug in dcmseg that produced broken binary Segmentation objects if the
+  number of pixels were not dividable by 8 for a single frame.
 
-  - Many further improvements in order to stay up-to-date with development of
-    the DICOM standard and to make it easier to use this module and its classes.
+- Enhanced Worklist SCP code to make use of existing classes and functions
+  instead of using its own "spaghetti" code for everything.  This also
+  resolves issues with the Worklist SCP rejecting some legit Worklist queries
+  as its own verification functions were too strict.
 
-- Added options to findscu that extract the C-FIND response datasets to XML
-  files (either a single file with all responses or separate files for each
-  response, similar to the existing --extract option).
+- Introduced a subset of std::filesystem to ofstd, currently providing the
+  classes OFpath, OFdirectory_entry and OFdirectory_iterator as portable
+  implementations for the respective C++17 STL classes.
 
-- Added option --socket-timeout to echoscu (same as for e.g. storescu).
+- The Windows implementation of class OFReadWriteLock class now uses Slim
+  Reader/Writer (SRW) Locks, which are available since Windows Vista, instead
+  of the older implementation based on a Mutex, a Semaphore and a counter,
+  because SRW locks are much faster.
 
-- Consistently use the default value "MEDIUM" for Priority in all DIMSE request
-  messages, i.e. for C-STORE, C-FIND, C-GET and C-MOVE.
+- Changed version numbering of shared objects.  On Posix operating systems,
+  it now follows these guidelines: https://autotools.io/libtool/version.html.
 
-- Fixed various issues that occurred after the official 3.6.2 release.
+- Fixed various issues that occurred after the official 3.6.3 release.
+  See CHANGES file for details.
 
 
 Many people have contributed to this new release of DCMTK, appearing here in
 alphabetical order.  Thank you very much for your support!
 
-  Domen Soklic <domen.soklic@cosylab.com>
+  Klaus Eisentraut <klaus.eisentraut@siemens-healthineers.com>
+  Andrey Fedorov <andrey.fedorov@gmail.com>
+  Florian Franzen <Florian.Franzen@caesar.de>
+  Christian Fremgen <Christian.Fremgen@ith-icoserve.com>
+  Omar Ganiev <beched@deteact.com>
+  Daniel Grieger <Daniel.Grieger@ith-icoserve.com>
+  Helmut Grohne <helmut@subdivi.de>
   GwanYeong Kim <gy741.kim@gmail.com>
-  Jean-Christophe Fillion-Robin <jchris.fillionr@kitware.com>
-  Joerg Koenig <joerg.koenig@zeiss.com>
-  Michael Craggs <Michael.Craggs@ith-icoserve.com>
   Peter Klotz <Peter.Klotz@ith-icoserve.com>
-
-  Helmut Steiner
-  Max Smolens
-  Martin Strunz
-  Sergei Khlutchin
-
-  Forum user "Hafiz Rafeeq"
-  Forum user "sfzhang"
+  Mathieu Malaterre <mathieu.malaterre@gmail.com>
+  Savvas Metallidis <savvas.metallidis@infomedcs.com>
+  Isaiah Norton <inorton@bwh.harvard.edu>
+  Lukas Raesenhoeft <lukas@raesenhoeft.com>
+  Uli Schlachter <psychon@znc.in>
+  Max Smolens (github user msmolens)
+  Christian Wetzel <wetzel@phoenix-pacs.de>
+  Gert Wollny <gw.fossdev@gmail.com>
+  Sahab Zanjanizadeh <Sahab.Zanjanizadeh@ge.com>
+
+  Thomas Dement
+  Hans Johnson (GitHub user "hjmjohnson")
+
+  Forum user "deepakt"
+  GitHub user "sercxjo"
 
 Members of the DCMTK Team who have worked on this release are
 (in alphabetical order):
 
+  Pedro Arizpe Gomez <arizpegomez@offis.de>
   Marco Eichelberg <eichelberg@offis.de>
   Michael Onken <onken@open-connections.de>
   Joerg Riesmeier <dicom@jriesmeier.com>
@@ -106,13 +153,12 @@ Members of the DCMTK Team who have worked on this release are
 Student associates:
 
   Nikolas Goldhammer <nikolasgoldhammer@gmail.com>
-  Sebastian Grallert <Grallert.Sebastian@web.de>
 
 Also see CREDITS file for projects and companies who have been generously
 supporting DCMTK.
 
 The DCMTK software can be downloaded via:
 
-  http://dicom.offis.de/dcmtk or http://www.dcmtk.org/
+  https://dicom.offis.de/dcmtk or https://www.dcmtk.org/
 
-OFFIS e.V., Oldenburg, Germany, 2018-02-05
+OFFIS e.V., Oldenburg, Germany, 2018-11-29

CMake/CTest/CTestCustomAndroid.cmake.in

@@ -5,36 +5,36 @@
 #
 
 # Restore the required settings of the CMake configuration step
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-SET(CMAKE_COMMAND "@CMAKE_COMMAND@")
-SET(CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@")
-SET(CMAKE_CURRENT_BINARY_DIR "@CMAKE_BINARY_DIR@")
-SET(CMAKE_FILES_DIRECTORY "@CMAKE_FILES_DIRECTORY@")
-SET(CMAKE_MODULE_PATH "@CMAKE_ROOT@/Modules")
-SET(CMAKE_SHARED_LIBRARY_PREFIX "@CMAKE_SHARED_LIBRARY_PREFIX@")
-SET(CMAKE_SHARED_LIBRARY_SUFFIX "@CMAKE_SHARED_LIBRARY_SUFFIX@")
-SET(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@")
-SET(DCMTK_CMAKE_INCLUDE "@CMAKE_SOURCE_DIR@/@DCMTK_CMAKE_INCLUDE@")
-SET(DCMTK_TEST_EXECUTABLES "@DCMTK_TEST_EXECUTABLES@")
-SET(DCMTK_ALL_LIBRARIES "@DCMTK_ALL_LIBRARIES@")
-SET(DCMTK_LIBRARY_DEPENDENCIES "@DCMTK_LIBRARY_DEPENDENCIES@")
-SET(DCMTK_PACKAGE_VERSION "@DCMTK_PACKAGE_VERSION@")
-SET(DCMTK_ABI_VERSION "@DCMTK_ABI_VERSION@")
-SET(BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")
-SET(DCMTK_DICOM_DICTIONARIES "@DCMTK_DICOM_DICTIONARIES@")
-SET(ANDROID "@ANDROID@")
-SET(ANDROID_ADB_PROGRAM "@ANDROID_ADB_PROGRAM@")
-SET(ANDROID_ANDROID_PROGRAM "@ANDROID_ANDROID_PROGRAM@")
-SET(ANDROID_EMULATOR_PROGRAM "@ANDROID_EMULATOR_PROGRAM@")
-SET(ANDROID_EMULATOR_AVD "@ANDROID_EMULATOR_AVD@")
-SET(ANDROID_RUNTIME_LIBRARIES "@ANDROID_RUNTIME_LIBRARIES@")
-SET(ANDROID_TEMPORARY_FILES_LOCATION "@ANDROID_TEMPORARY_FILES_LOCATION@")
+cmake_minimum_required(VERSION 2.6)
+set(CMAKE_COMMAND "@CMAKE_COMMAND@")
+set(CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@")
+set(CMAKE_CURRENT_BINARY_DIR "@CMAKE_BINARY_DIR@")
+set(CMAKE_FILES_DIRECTORY "@CMAKE_FILES_DIRECTORY@")
+set(CMAKE_MODULE_PATH "@CMAKE_ROOT@/Modules")
+set(CMAKE_SHARED_LIBRARY_PREFIX "@CMAKE_SHARED_LIBRARY_PREFIX@")
+set(CMAKE_SHARED_LIBRARY_SUFFIX "@CMAKE_SHARED_LIBRARY_SUFFIX@")
+set(CMAKE_HOST_SYSTEM "@CMAKE_HOST_SYSTEM@")
+set(DCMTK_CMAKE_INCLUDE "@CMAKE_SOURCE_DIR@/@DCMTK_CMAKE_INCLUDE@")
+set(DCMTK_TEST_EXECUTABLES "@DCMTK_TEST_EXECUTABLES@")
+set(DCMTK_ALL_LIBRARIES "@DCMTK_ALL_LIBRARIES@")
+set(DCMTK_LIBRARY_DEPENDENCIES "@DCMTK_LIBRARY_DEPENDENCIES@")
+set(DCMTK_PACKAGE_VERSION "@DCMTK_PACKAGE_VERSION@")
+set(DCMTK_ABI_VERSION "@DCMTK_ABI_VERSION@")
+set(BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@")
+set(DCMTK_DICOM_DICTIONARIES "@DCMTK_DICOM_DICTIONARIES@")
+set(ANDROID "@ANDROID@")
+set(ANDROID_ADB_PROGRAM "@ANDROID_ADB_PROGRAM@")
+set(ANDROID_ANDROID_PROGRAM "@ANDROID_ANDROID_PROGRAM@")
+set(ANDROID_EMULATOR_PROGRAM "@ANDROID_EMULATOR_PROGRAM@")
+set(ANDROID_EMULATOR_AVD "@ANDROID_EMULATOR_AVD@")
+set(ANDROID_RUNTIME_LIBRARIES "@ANDROID_RUNTIME_LIBRARIES@")
+set(ANDROID_TEMPORARY_FILES_LOCATION "@ANDROID_TEMPORARY_FILES_LOCATION@")
 # Emulate some required CMake commands while running inside CTest
-INCLUDE(${DCMTK_CMAKE_INCLUDE}CMake/CTest/dcmtkCTestMacros.cmake)
+include(${DCMTK_CMAKE_INCLUDE}CMake/CTest/dcmtkCTestMacros.cmake)
 # For DCMTK_UNSET_XXX
-INCLUDE(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkMacros.cmake)
+include(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkMacros.cmake)
 # Load required functions for controlling the Android device emulator
-INCLUDE(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkUseAndroidSDK.cmake)
+include(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkUseAndroidSDK.cmake)
 
 # Prepare the Android testing environment
 # Prepare the emulator
@@ -51,20 +51,20 @@ MESSAGE_COMMAND(STOP_MESSAGE ${STOP_MESSAGE})
 # CTEST_CUSTOM_POST_TESTS executes a sequence of 'non CMake' commands separated
 # by ';' characters. Therefore the sequence a single command consists of must
 # be translated appropriately first
-STRING(REPLACE ";" " " STOP_EMULATOR "${STOP_EMULATOR}")
-STRING(REPLACE ";" " " STOP_MESSAGE "${STOP_MESSAGE}")
+string(REPLACE ";" " " STOP_EMULATOR "${STOP_EMULATOR}")
+string(REPLACE ";" " " STOP_MESSAGE "${STOP_MESSAGE}")
 # Register the cleanup hooks
-SET(CTEST_CUSTOM_POST_TEST "${STOP_MESSAGE}" "${STOP_EMULATOR}")
+set(CTEST_CUSTOM_POST_TEST "${STOP_MESSAGE}" "${STOP_EMULATOR}")
 
 # Set the current emulator instance handle via an environment variable
-SET(ENV{DCMTK_ANDROID_EMULATOR_INSTANCE} "${DCMTK_ANDROID_EMULATOR_INSTANCE}")
+set(ENV{DCMTK_ANDROID_EMULATOR_INSTANCE} "${DCMTK_ANDROID_EMULATOR_INSTANCE}")
 
 # Collect the list of required libraries
-IF(BUILD_SHARED_LIBS)
-    FOREACH(LIBRARY ${DCMTK_ALL_LIBRARIES})
-        LIST(APPEND DCMTK_CREATED_SHARED_LIBRARIES "${CMAKE_BINARY_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY}${CMAKE_SHARED_LIBRARY_SUFFIX}.${DCMTK_PACKAGE_VERSION}")
-    ENDFOREACH()
-ENDIF(BUILD_SHARED_LIBS)
+if(BUILD_SHARED_LIBS)
+    foreach(LIBRARY ${DCMTK_ALL_LIBRARIES})
+        list(APPEND DCMTK_CREATED_SHARED_LIBRARIES "${CMAKE_BINARY_DIR}/lib/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY}${CMAKE_SHARED_LIBRARY_SUFFIX}.${DCMTK_PACKAGE_VERSION}")
+    endforeach()
+endif()
 
 # Transmit the required executables, libraries and dictionaries to the emulator
 DCMTK_ANDROID_PUSH(DCMTK_ANDROID_EMULATOR_INSTANCE
@@ -77,22 +77,22 @@ DCMTK_ANDROID_PUSH(DCMTK_ANDROID_EMULATOR_INSTANCE
 )
 
 # Set executable permissions
-FOREACH(TEST_EXECUTABLE ${DCMTK_TEST_EXECUTABLES})
-    GET_FILENAME_COMPONENT(NAME "${TEST_EXECUTABLE}" NAME)
+foreach(TEST_EXECUTABLE ${DCMTK_TEST_EXECUTABLES})
+    get_filename_component(NAME "${TEST_EXECUTABLE}" NAME)
     DCMTK_ANDROID_SHELL(DCMTK_ANDROID_EMULATOR_INSTANCE
         COMMAND chmod 755 "${ANDROID_TEMPORARY_FILES_LOCATION}/${NAME}"
         OUTPUT_QUIET
         ERROR_QUIET
     )
-ENDFOREACH()
+endforeach()
 
 # Create necessary softlinks
-IF(BUILD_SHARED_LIBS)
-    FOREACH(LIBRARY ${DCMTK_ALL_LIBRARIES})
+if(BUILD_SHARED_LIBS)
+    foreach(LIBRARY ${DCMTK_ALL_LIBRARIES})
         DCMTK_ANDROID_SHELL(DCMTK_ANDROID_EMULATOR_INSTANCE
         COMMAND ln -s "./${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY}${CMAKE_SHARED_LIBRARY_SUFFIX}.${DCMTK_PACKAGE_VERSION}" "${ANDROID_TEMPORARY_FILES_LOCATION}/${CMAKE_SHARED_LIBRARY_PREFIX}${LIBRARY}${CMAKE_SHARED_LIBRARY_SUFFIX}.${DCMTK_ABI_VERSION}"
         OUTPUT_QUIET
         ERROR_QUIET
         )
-    ENDFOREACH()
-ENDIF(BUILD_SHARED_LIBS)
+    endforeach()
+endif()

CMake/CTest/CTestCustomWine.cmake.in

@@ -4,13 +4,13 @@
 # workaround, but what can you do?
 #
 
-SET(ENV{WINEPREFIX} "@DCMTK_WINEPREFIX@")
-SET(ENV{DCMDICTPATH} "@DCMDICTPATH@")
-SET(WINE_WINE_PROGRAM "@WINE_WINE_PROGRAM@")
+set(ENV{WINEPREFIX} "@DCMTK_WINEPREFIX@")
+set(ENV{DCMDICTPATH} "@DCMDICTPATH@")
+set(WINE_WINE_PROGRAM "@WINE_WINE_PROGRAM@")
 
 # spawn the winserver using 'cmd /C call' -> effectively NOP
 # spawn it using 'sh', such that this script does not attach itself to it.
-EXECUTE_PROCESS(COMMAND
+execute_process(COMMAND
     sh -c "\"${WINE_WINE_PROGRAM}\" cmd /C call"
     OUTPUT_FILE "/dev/null"
     ERROR_FILE "/dev/null"

CMake/CTest/dcmtkCTestMacros.cmake

@@ -3,25 +3,25 @@
 # that is missing inside CTest.
 #
 
-MACRO(MESSAGE_COMMAND VAR MODE)
-    IF(${MODE} STREQUAL "STATUS")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo -- ${ARGN})
-    ELSEIF(${MODE} STREQUAL "WARNING")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo WARNING: ${ARGN})
-    ELSEIF(${MODE} STREQUAL "AUTHOR_WARNING")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo Warning: ${ARGN})
-    ELSEIF(${MODE} STREQUAL "SEND_ERROR")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo Error: ${ARGN})
-    ELSEIF(${MODE} STREQUAL "FATAL_ERROR")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo ERROR: ${ARGN})
-    ELSEIF(${MODE} STREQUAL "DEPRECATION")
-        SET(${VAR} ${CMAKE_COMMAND} -E echo ${ARGN})
-    ELSE()
-        SET(${VAR} ${CMAKE_COMMAND} -E echo ${MODE} ${ARGN})
-    ENDIF()
-ENDMACRO(MESSAGE_COMMAND)
+macro(MESSAGE_COMMAND VAR MODE)
+    if(${MODE} STREQUAL "STATUS")
+        set(${VAR} ${CMAKE_COMMAND} -E echo -- ${ARGN})
+    elseif(${MODE} STREQUAL "WARNING")
+        set(${VAR} ${CMAKE_COMMAND} -E echo WARNING: ${ARGN})
+    elseif(${MODE} STREQUAL "AUTHOR_WARNING")
+        set(${VAR} ${CMAKE_COMMAND} -E echo Warning: ${ARGN})
+    elseif(${MODE} STREQUAL "SEND_ERROR")
+        set(${VAR} ${CMAKE_COMMAND} -E echo Error: ${ARGN})
+    elseif(${MODE} STREQUAL "FATAL_ERROR")
+        set(${VAR} ${CMAKE_COMMAND} -E echo ERROR: ${ARGN})
+    elseif(${MODE} STREQUAL "DEPRECATION")
+        set(${VAR} ${CMAKE_COMMAND} -E echo ${ARGN})
+    else()
+        set(${VAR} ${CMAKE_COMMAND} -E echo ${MODE} ${ARGN})
+    endif()
+endmacro()
 
-FUNCTION(MESSAGE)
+function(MESSAGE)
     MESSAGE_COMMAND(COMMAND ${ARGN})
-    EXECUTE_PROCESS(COMMAND ${COMMAND})
-ENDFUNCTION(MESSAGE)
+    execute_process(COMMAND ${COMMAND})
+endfunction()

CMake/CTest/dcmtkCTestRun.cmake.in

@@ -4,15 +4,15 @@
 # environment variable appropriately.
 #
 
-SET(ENV{DCMDICTPATH} "@DCMDICTPATH@")
+set(ENV{DCMDICTPATH} "@DCMDICTPATH@")
 
-EXECUTE_PROCESS(COMMAND
+execute_process(COMMAND
     "${DCMTK_CTEST_TESTCASE_COMMAND}" $ENV{DCMTK_CTEST_EXTRA_ARGUMENTS} "${DCMTK_CTEST_TEST_NAME}"
     RESULT_VARIABLE RESULT
 )
 
 # We cannot forward the result value to CMake, so print it instead and let CMake
 # return with code '1' or whatever it deems appropriate to notify about an error.
-IF(RESULT)
-    MESSAGE(FATAL_ERROR "Test command returned: ${RESULT}")
-ENDIF()
+if(RESULT)
+    message(FATAL_ERROR "Test command returned: ${RESULT}")
+endif()

CMake/CTest/dcmtkCTestRunAndroid.cmake.in

@@ -6,18 +6,18 @@
 #
 
 # Restore the required settings of the CMake configuration step
-SET(CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@")
-SET(CMAKE_CURRENT_BINARY_DIR "@CMAKE_BINARY_DIR@")
-SET(CMAKE_FILES_DIRECTORY "@CMAKE_FILES_DIRECTORY@")
-SET(DCMTK_CMAKE_INCLUDE "@CMAKE_SOURCE_DIR@/@DCMTK_CMAKE_INCLUDE@")
-SET(DCMDICTPATH "@DCMDICTPATH@")
-SET(ANDROID_ADB_PROGRAM "@ANDROID_ADB_PROGRAM@")
-SET(ANDROID_TEMPORARY_FILES_LOCATION "@ANDROID_TEMPORARY_FILES_LOCATION@")
+set(CMAKE_BINARY_DIR "@CMAKE_BINARY_DIR@")
+set(CMAKE_CURRENT_BINARY_DIR "@CMAKE_BINARY_DIR@")
+set(CMAKE_FILES_DIRECTORY "@CMAKE_FILES_DIRECTORY@")
+set(DCMTK_CMAKE_INCLUDE "@CMAKE_SOURCE_DIR@/@DCMTK_CMAKE_INCLUDE@")
+set(DCMDICTPATH "@DCMDICTPATH@")
+set(ANDROID_ADB_PROGRAM "@ANDROID_ADB_PROGRAM@")
+set(ANDROID_TEMPORARY_FILES_LOCATION "@ANDROID_TEMPORARY_FILES_LOCATION@")
 # Load required functions for controlling the Android device emulator
-INCLUDE(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkUseAndroidSDK.cmake)
+include(${DCMTK_CMAKE_INCLUDE}CMake/dcmtkUseAndroidSDK.cmake)
 
 # Restore the Android device emulator instance handle
-SET(DCMTK_ANDROID_EMULATOR_INSTANCE "$ENV{DCMTK_ANDROID_EMULATOR_INSTANCE}")
+set(DCMTK_ANDROID_EMULATOR_INSTANCE "$ENV{DCMTK_ANDROID_EMULATOR_INSTANCE}")
 
 # Run the actual testcase on the remote device
 DCMTK_ANDROID_SHELL(DCMTK_ANDROID_EMULATOR_INSTANCE
@@ -28,6 +28,6 @@ DCMTK_ANDROID_SHELL(DCMTK_ANDROID_EMULATOR_INSTANCE
 
 # We cannot forward the result value to CTest, so print it instead and let CMake
 # return with code '1' or whatever it deems appropriate to notify about an error.
-IF(RESULT)
-    MESSAGE(FATAL_ERROR "Test command returned: ${RESULT}")
-ENDIF()
+if(RESULT)
+    message(FATAL_ERROR "Test command returned: ${RESULT}")
+endif()

CMake/CTest/dcmtkCTestRunExhaustive.cmake

@@ -2,5 +2,5 @@
 # this file is used to execute the unit tests with the -x option injected
 #
 
-SET(ENV{DCMTK_CTEST_EXTRA_ARGUMENTS} "-x")
-EXECUTE_PROCESS(COMMAND ${CMAKE_CTEST_COMMAND} -C "${CONFIG}")
+set(ENV{DCMTK_CTEST_EXTRA_ARGUMENTS} "-x")
+execute_process(COMMAND ${CMAKE_CTEST_COMMAND} -C "${CONFIG}")

CMake/CTest/dcmtkCTestRunWine.cmake.in

@@ -7,17 +7,17 @@
 # shutdown.
 #
 
-SET(ENV{WINEPREFIX} "@DCMTK_WINEPREFIX@")
-SET(ENV{DCMDICTPATH} "@DCMDICTPATH@")
-SET(WINE_WINE_PROGRAM "@WINE_WINE_PROGRAM@")
+set(ENV{WINEPREFIX} "@DCMTK_WINEPREFIX@")
+set(ENV{DCMDICTPATH} "@DCMDICTPATH@")
+set(WINE_WINE_PROGRAM "@WINE_WINE_PROGRAM@")
 
-EXECUTE_PROCESS(COMMAND
+execute_process(COMMAND
     "${WINE_WINE_PROGRAM}" "${DCMTK_CTEST_TESTCASE_COMMAND}" $ENV{DCMTK_CTEST_EXTRA_ARGUMENTS} "${DCMTK_CTEST_TEST_NAME}"
     RESULT_VARIABLE RESULT
 )
 
 # We cannot forward the result value to CMake, so print it instead and let CMake
 # return with code '1' or whatever it deems appropriate to notify about an error.
-IF(RESULT)
-    MESSAGE(FATAL_ERROR "Test command returned: ${RESULT}")
-ENDIF()
+if(RESULT)
+    message(FATAL_ERROR "Test command returned: ${RESULT}")
+endif()

CMake/CheckCMakeCommandExists.cmake

 # Helper macro that checks whether a given CMake command exists or not
-MACRO(CHECK_CMAKE_COMMAND_EXISTS commandname)
-  MESSAGE(STATUS "Looking for CMake command ${commandname}")
+macro(CHECK_CMAKE_COMMAND_EXISTS commandname)
+  message(STATUS "Looking for CMake command ${commandname}")
   string(TOUPPER ${commandname} commandname_upper)
-  IF(COMMAND ${commandname})
-    SET(HAVE_${commandname_upper} TRUE)
-    MESSAGE(STATUS "Looking for CMake command ${commandname} - found")
-  ELSE()
-    SET(HAVE_${commandname_upper} FALSE)
-    MESSAGE(STATUS "Looking for CMake command ${commandname} - not found")
-  ENDIF()
-ENDMACRO()
+  if(COMMAND ${commandname})
+    set(HAVE_${commandname_upper} TRUE)
+    message(STATUS "Looking for CMake command ${commandname} - found")
+  else()
+    set(HAVE_${commandname_upper} FALSE)
+    message(STATUS "Looking for CMake command ${commandname} - not found")
+  endif()
+endmacro()

CMake/CheckFunctionWithHeaderExists.cmake

@@ -8,26 +8,26 @@
 # ... - additional arguments will be interpreted as additional libraries to link during testing.
 #
 
-MACRO(CHECK_FUNCTIONWITHHEADER_EXISTS SYMBOL FILES VARIABLE)
-  IF(NOT DEFINED "${VARIABLE}")
-    SET(CHECK_SYMBOL_EXISTS_CONTENT "/* */\n")
-    SET(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS})
-    IF(CMAKE_REQUIRED_LIBRARIES)
-      SET(CHECK_SYMBOL_EXISTS_LIBS
+macro(CHECK_FUNCTIONWITHHEADER_EXISTS SYMBOL FILES VARIABLE)
+  if(NOT DEFINED "${VARIABLE}")
+    set(CHECK_SYMBOL_EXISTS_CONTENT "/* */\n")
+    set(MACRO_CHECK_SYMBOL_EXISTS_FLAGS ${CMAKE_REQUIRED_FLAGS})
+    if(CMAKE_REQUIRED_LIBRARIES)
+      set(CHECK_SYMBOL_EXISTS_LIBS
         "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES};${ARGN}")
-    ENDIF(CMAKE_REQUIRED_LIBRARIES)
-    FOREACH(FILE ${FILES})
-      SET(CHECK_SYMBOL_EXISTS_CONTENT
+    endif()
+    foreach(FILE ${FILES})
+      set(CHECK_SYMBOL_EXISTS_CONTENT
         "${CHECK_SYMBOL_EXISTS_CONTENT}#include <${FILE}>\n")
-    ENDFOREACH(FILE)
-    SET(CHECK_SYMBOL_EXISTS_CONTENT
+    endforeach()
+    set(CHECK_SYMBOL_EXISTS_CONTENT
       "${CHECK_SYMBOL_EXISTS_CONTENT}\nint main()\n{\n${SYMBOL};return 0;\n}\n")
 
-    FILE(WRITE ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.cxx
+    file(WRITE ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.cxx
       "${CHECK_SYMBOL_EXISTS_CONTENT}")
 
-    MESSAGE(STATUS "Looking for prototype of ${SYMBOL}")
-    TRY_COMPILE(${VARIABLE}
+    message(STATUS "Looking for prototype of ${SYMBOL}")
+    try_compile(${VARIABLE}
       "${CMAKE_BINARY_DIR}"
       "${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.cxx"
       CMAKE_FLAGS
@@ -36,22 +36,22 @@ MACRO(CHECK_FUNCTIONWITHHEADER_EXISTS SYMBOL FILES VARIABLE)
       "${CHECK_SYMBOL_EXISTS_LIBS}"
       ${DCMTK_TRY_COMPILE_REQUIRED_CMAKE_FLAGS}
       OUTPUT_VARIABLE OUTPUT)
-    IF(${VARIABLE})
-      MESSAGE(STATUS "Looking for prototype of ${SYMBOL} - found")
-      SET(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}")
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log"
+    if(${VARIABLE})
+      message(STATUS "Looking for prototype of ${SYMBOL} - found")
+      set(${VARIABLE} 1 CACHE INTERNAL "Have symbol ${SYMBOL}")
+      file(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log"
         "Determining if the ${SYMBOL} "
         "exist passed with the following output:\n"
         "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.ccc:\n"
         "${CHECK_SYMBOL_EXISTS_CONTENT}\n")
-    ELSE(${VARIABLE})
-      MESSAGE(STATUS "Looking for prototype of ${SYMBOL} - not found.")
-      SET(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}")
-      FILE(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
+    else()
+      message(STATUS "Looking for prototype of ${SYMBOL} - not found.")
+      set(${VARIABLE} "" CACHE INTERNAL "Have symbol ${SYMBOL}")
+      file(APPEND "${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log"
         "Determining if the ${SYMBOL} "
         "exist failed with the following output:\n"
         "${OUTPUT}\nFile ${CMAKE_BINARY_DIR}/CMakeTmp/CheckSymbolExists.cxx:\n"
         "${CHECK_SYMBOL_EXISTS_CONTENT}\n")
-    ENDIF(${VARIABLE})
-  ENDIF(NOT DEFINED "${VARIABLE}")
-ENDMACRO(CHECK_FUNCTIONWITHHEADER_EXISTS)
+    endif()
+  endif()
+endmacro()

CMake/DCMTKConfig.cmake.in

@@ -5,56 +5,56 @@
 @PACKAGE_INIT@
 
 # Basic version information
-SET(DCMTK_MAJOR_VERSION @DCMTK_MAJOR_VERSION@)
-SET(DCMTK_MINOR_VERSION @DCMTK_MINOR_VERSION@)
-SET(DCMTK_BUILD_VERSION @DCMTK_BUILD_VERSION@)
+set(DCMTK_MAJOR_VERSION @DCMTK_MAJOR_VERSION@)
+set(DCMTK_MINOR_VERSION @DCMTK_MINOR_VERSION@)
+set(DCMTK_BUILD_VERSION @DCMTK_BUILD_VERSION@)
 
 # DCMTK libraries and modules
-SET(DCMTK_MODULES "@DCMTK_MODULES@")
-SET(DCMTK_LIBRARIES "@DCMTK_LIBRARY_TARGETS@")
+set(DCMTK_MODULES "@DCMTK_MODULES@")
+set(DCMTK_LIBRARIES "@DCMTK_LIBRARY_TARGETS@")
 
 # Optional DCMTK 3rd party libraries
-SET(DCMTK_WITH_TIFF @DCMTK_WITH_TIFF@)
-SET(DCMTK_WITH_PNG @DCMTK_WITH_PNG@)
-SET(DCMTK_WITH_XML @DCMTK_WITH_XML@)
-SET(DCMTK_WITH_ZLIB @DCMTK_WITH_ZLIB@)
-SET(DCMTK_WITH_OPENSSL @DCMTK_WITH_OPENSSL@)
-SET(DCMTK_WITH_SNDFILE @DCMTK_WITH_SNDFILE@)
-SET(DCMTK_WITH_ICONV @DCMTK_WITH_ICONV@)
-SET(DCMTK_WITH_STDLIBC_ICONV @DCMTK_WITH_STDLIBC_ICONV@)
-SET(DCMTK_WITH_ICU @DCMTK_WITH_ICU@)
-SET(DCMTK_WITH_WRAP @DCMTK_WITH_WRAP@)
-SET(DCMTK_WITH_DOXYGEN @DCMTK_WITH_DOXYGEN@)
+set(DCMTK_WITH_TIFF @DCMTK_WITH_TIFF@)
+set(DCMTK_WITH_PNG @DCMTK_WITH_PNG@)
+set(DCMTK_WITH_XML @DCMTK_WITH_XML@)
+set(DCMTK_WITH_ZLIB @DCMTK_WITH_ZLIB@)
+set(DCMTK_WITH_OPENSSL @DCMTK_WITH_OPENSSL@)
+set(DCMTK_WITH_SNDFILE @DCMTK_WITH_SNDFILE@)
+set(DCMTK_WITH_ICONV @DCMTK_WITH_ICONV@)
+set(DCMTK_WITH_STDLIBC_ICONV @DCMTK_WITH_STDLIBC_ICONV@)
+set(DCMTK_WITH_ICU @DCMTK_WITH_ICU@)
+set(DCMTK_WITH_WRAP @DCMTK_WITH_WRAP@)
+set(DCMTK_WITH_DOXYGEN @DCMTK_WITH_DOXYGEN@)
 
 # Dictionary-related
-SET(DCMTK_ENABLE_BUILTIN_DICTIONARY @DCMTK_ENABLE_BUILTIN_DICTIONARY@)
-SET(DCMTK_ENABLE_EXTERNAL_DICTIONARY @DCMTK_ENABLE_EXTERNAL_DICTIONARY@)
-SET(DCMTK_ENABLE_PRIVATE_TAGS @DCMTK_ENABLE_PRIVATE_TAGS@)
+set(DCMTK_ENABLE_BUILTIN_DICTIONARY @DCMTK_ENABLE_BUILTIN_DICTIONARY@)
+set(DCMTK_ENABLE_EXTERNAL_DICTIONARY @DCMTK_ENABLE_EXTERNAL_DICTIONARY@)
+set(DCMTK_ENABLE_PRIVATE_TAGS @DCMTK_ENABLE_PRIVATE_TAGS@)
 
 # Compiler / standard library features
-SET(DCMTK_ENABLE_CXX11 @DCMTK_ENABLE_CXX11@)
-SET(DCMTK_CXX11_FLAGS @DCMTK_CXX11_FLAGS@)
-SET(DCMTK_ENABLE_STL @DCMTK_ENABLE_STL@)
+set(DCMTK_ENABLE_CXX11 @DCMTK_ENABLE_CXX11@)
+set(DCMTK_CXX11_FLAGS @DCMTK_CXX11_FLAGS@)
+set(DCMTK_ENABLE_STL @DCMTK_ENABLE_STL@)
 
 # DCMTK shared libraries
-SET(DCMTK_SHARED_LIBRARIES @BUILD_SHARED_LIBS@)
-SET(DCMTK_SINGLE_SHARED_LIBRARY @BUILD_SINGLE_SHARED_LIBRARY@)
+set(DCMTK_SHARED_LIBRARIES @BUILD_SHARED_LIBS@)
+set(DCMTK_SINGLE_SHARED_LIBRARY @BUILD_SINGLE_SHARED_LIBRARY@)
 
 # DCMTK additional options
-SET(DCMTK_WITH_THREADS @DCMTK_WITH_THREADS@)
-SET(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS @DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS@)
-SET(DCMTK_WIDE_CHAR_FILE_IO_FUNCTIONS @DCMTK_WIDE_CHAR_FILE_IO_FUNCTIONS@)
-SET(DCMTK_WIDE_CHAR_MAIN_FUNCTION @DCMTK_WIDE_CHAR_MAIN_FUNCTION@)
-SET(DCMTK_ENABLE_LFS @DCMTK_ENABLE_LFS@)
+set(DCMTK_WITH_THREADS @DCMTK_WITH_THREADS@)
+set(DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS @DCMTK_OVERWRITE_WIN32_COMPILER_FLAGS@)
+set(DCMTK_WIDE_CHAR_FILE_IO_FUNCTIONS @DCMTK_WIDE_CHAR_FILE_IO_FUNCTIONS@)
+set(DCMTK_WIDE_CHAR_MAIN_FUNCTION @DCMTK_WIDE_CHAR_MAIN_FUNCTION@)
+set(DCMTK_ENABLE_LFS @DCMTK_ENABLE_LFS@)
 
 SET_AND_CHECK(DCMTK_TARGETS "@PACKAGE_DCMTK_CMKDIR_CONFIG@/DCMTKTargets.cmake")
 
 @DCMTK_CONFIG_CODE@
 
 # Compatibility: This variable is deprecated
-SET(DCMTK_INCLUDE_DIR ${DCMTK_INCLUDE_DIRS})
+set(DCMTK_INCLUDE_DIR ${DCMTK_INCLUDE_DIRS})
 
-IF(NOT DCMTK_TARGETS_IMPORTED)
-  SET(DCMTK_TARGETS_IMPORTED 1)
-  INCLUDE(${DCMTK_TARGETS})
-ENDIF(NOT DCMTK_TARGETS_IMPORTED)
+if(NOT DCMTK_TARGETS_IMPORTED)
+  set(DCMTK_TARGETS_IMPORTED 1)
+  include(${DCMTK_TARGETS})
+endif()

CMake/FindCharset.cmake

@@ -4,19 +4,19 @@
 #  LIBCHARSET_LIBRARIES    - Lists of libraries when using charset
 #  LIBCHARSET_FOUND        - True if charset found
 
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
 
 # Look for the header file
-FIND_PATH(LIBCHARSET_INCLUDE_DIR NAMES localcharset.h)
-MARK_AS_ADVANCED(LIBCHARSET_INCLUDE_DIR)
+find_path(LIBCHARSET_INCLUDE_DIR NAMES localcharset.h)
+mark_as_advanced(LIBCHARSET_INCLUDE_DIR)
 
-SET(LIBCHARSET_LIBS charset)
-FIND_LIBRARY(LIBCHARSET_LIBRARY NAMES ${LIBCHARSET_LIBS})
-MARK_AS_ADVANCED(LIBCHARSET_LIBRARY)
+set(LIBCHARSET_LIBS charset)
+find_library(LIBCHARSET_LIBRARY NAMES ${LIBCHARSET_LIBS})
+mark_as_advanced(LIBCHARSET_LIBRARY)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBCHARSET REQUIRED_VARS LIBCHARSET_LIBRARY LIBCHARSET_INCLUDE_DIR)
 
-IF(LIBCHARSET_FOUND)
-  SET(LIBCHARSET_INCLUDE_DIRS ${LIBCHARSET_INCLUDE_DIR})
-  SET(LIBCHARSET_LIBRARIES ${LIBCHARSET_LIBRARY})
-ENDIF(LIBCHARSET_FOUND)
+if(LIBCHARSET_FOUND)
+  set(LIBCHARSET_INCLUDE_DIRS ${LIBCHARSET_INCLUDE_DIR})
+  set(LIBCHARSET_LIBRARIES ${LIBCHARSET_LIBRARY})
+endif()

CMake/FindICONV.cmake → CMake/FindIconv.cmake

@@ -6,28 +6,28 @@
 #  LIBICONV_LIBRARIES    - Lists of libraries when using iconv
 #  LIBICONV_FOUND        - True if iconv found
 
-INCLUDE(FindPackageHandleStandardArgs)
-INCLUDE(dcmtkTryCompile)
+include(FindPackageHandleStandardArgs)
+include(dcmtkTryCompile)
 
 # Look for the header file
-FIND_PATH(LIBICONV_INCLUDE_DIR NAMES iconv.h)
-MARK_AS_ADVANCED(LIBICONV_INCLUDE_DIR)
+find_path(LIBICONV_INCLUDE_DIR NAMES iconv.h)
+mark_as_advanced(LIBICONV_INCLUDE_DIR)
 
 # Look for the library
-SET(LIBICONV_LIBS iconv)
-FIND_LIBRARY(LIBICONV_LIBRARY NAMES ${LIBICONV_LIBS})
-MARK_AS_ADVANCED(LIBICONV_LIBRARY)
+set(LIBICONV_LIBS iconv)
+find_library(LIBICONV_LIBRARY NAMES ${LIBICONV_LIBS})
+mark_as_advanced(LIBICONV_LIBRARY)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBICONV REQUIRED_VARS LIBICONV_LIBRARY LIBICONV_INCLUDE_DIR)
 
 # Copy the result to output variables
-IF(LIBICONV_FOUND)
-  SET(LIBICONV_LIBRARIES ${LIBICONV_LIBRARY})
-  SET(LIBICONV_INCLUDE_DIRS ${LIBICONV_INCLUDE_DIR})
-ELSE(LIBICONV_FOUND)
-  SET(LIBICONV_LIBS)
-  SET(LIBICONV_LIBRARY)
-  SET(LIBICONV_LIBRARIES)
-  SET(LIBICONV_INCLUDE_DIR)
-  SET(LIBICONV_INCLUDE_DIRS)
-ENDIF(LIBICONV_FOUND)
+if(LIBICONV_FOUND)
+  set(LIBICONV_LIBRARIES ${LIBICONV_LIBRARY})
+  set(LIBICONV_INCLUDE_DIRS ${LIBICONV_INCLUDE_DIR})
+else()
+  set(LIBICONV_LIBS)
+  set(LIBICONV_LIBRARY)
+  set(LIBICONV_LIBRARIES)
+  set(LIBICONV_INCLUDE_DIR)
+  set(LIBICONV_INCLUDE_DIRS)
+endif()

CMake/FindSndfile.cmake

@@ -6,27 +6,27 @@
 #  SNDFILE_LIBRARIES    - Lists of libraries when using sndfile
 #  SNDFILE_FOUND        - True if sndfile found
 
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
 
 # Look for the header file
-FIND_PATH(SNDFILE_INCLUDE_DIR NAMES sndfile.h)
-MARK_AS_ADVANCED(SNDFILE_INCLUDE_DIR)
+find_path(SNDFILE_INCLUDE_DIR NAMES sndfile.h)
+mark_as_advanced(SNDFILE_INCLUDE_DIR)
 
 # Look for the library
-SET(SNDFILE_LIBS sndfile)
-FIND_LIBRARY(SNDFILE_LIBRARY NAMES ${SNDFILE_LIBS})
-MARK_AS_ADVANCED(SNDFILE_LIBRARY)
+set(SNDFILE_LIBS sndfile)
+find_library(SNDFILE_LIBRARY NAMES ${SNDFILE_LIBS})
+mark_as_advanced(SNDFILE_LIBRARY)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(SNDFILE REQUIRED_VARS SNDFILE_LIBRARY SNDFILE_INCLUDE_DIR)
 
 # Copy the result to output variables
-IF(SNDFILE_FOUND)
-  SET(SNDFILE_LIBRARIES ${SNDFILE_LIBRARY})
-  SET(SNDFILE_INCLUDE_DIRS ${SNDFILE_INCLUDE_DIR})
-ELSE(SNDFILE_FOUND)
-  SET(SNDFILE_LIBS)
-  SET(SNDFILE_LIBRARY)
-  SET(SNDFILE_LIBRARIES)
-  SET(SNDFILE_INCLUDE_DIR)
-  SET(SNDFILE_INCLUDE_DIRS)
-ENDIF(SNDFILE_FOUND)
+if(SNDFILE_FOUND)
+  set(SNDFILE_LIBRARIES ${SNDFILE_LIBRARY})
+  set(SNDFILE_INCLUDE_DIRS ${SNDFILE_INCLUDE_DIR})
+else()
+  set(SNDFILE_LIBS)
+  set(SNDFILE_LIBRARY)
+  set(SNDFILE_LIBRARIES)
+  set(SNDFILE_INCLUDE_DIR)
+  set(SNDFILE_INCLUDE_DIRS)
+endif()

CMake/FindWrap.cmake

@@ -6,27 +6,27 @@
 #  WRAP_LIBRARIES    - Lists of libraries when using libwrap
 #  WRAP_FOUND        - True if wrap found
 
-INCLUDE(FindPackageHandleStandardArgs)
+include(FindPackageHandleStandardArgs)
 
 # Look for the header file
-FIND_PATH(WRAP_INCLUDE_DIR NAMES tcpd.h)
-MARK_AS_ADVANCED(WRAP_INCLUDE_DIR)
+find_path(WRAP_INCLUDE_DIR NAMES tcpd.h)
+mark_as_advanced(WRAP_INCLUDE_DIR)
 
 # Look for the library
-SET(WRAP_LIBS wrap)
-FIND_LIBRARY(WRAP_LIBRARY NAMES ${WRAP_LIBS})
-MARK_AS_ADVANCED(WRAP_LIBRARY)
+set(WRAP_LIBS wrap)
+find_library(WRAP_LIBRARY NAMES ${WRAP_LIBS})
+mark_as_advanced(WRAP_LIBRARY)
 
 FIND_PACKAGE_HANDLE_STANDARD_ARGS(WRAP REQUIRED_VARS WRAP_LIBRARY WRAP_INCLUDE_DIR)
 
 # Copy the result to output variables
-IF(WRAP_FOUND)
-  SET(WRAP_LIBRARIES ${WRAP_LIBRARY})
-  SET(WRAP_INCLUDE_DIRS ${WRAP_INCLUDE_DIR})
-ELSE(WRAP_FOUND)
-  SET(WRAP_LIBS)
-  SET(WRAP_LIBRARY)
-  SET(WRAP_LIBRARIES)
-  SET(WRAP_INCLUDE_DIR)
-  SET(WRAP_INCLUDE_DIRS)
-ENDIF(WRAP_FOUND)
+if(WRAP_FOUND)
+  set(WRAP_LIBRARIES ${WRAP_LIBRARY})
+  set(WRAP_INCLUDE_DIRS ${WRAP_INCLUDE_DIR})
+else()
+  set(WRAP_LIBS)
+  set(WRAP_LIBRARY)
+  set(WRAP_LIBRARIES)
+  set(WRAP_INCLUDE_DIR)
+  set(WRAP_INCLUDE_DIRS)
+endif()

CMake/GenerateCMakeExports.cmake

@@ -15,15 +15,15 @@
 # DCMTKConfig.cmake will contain options used to build this DCMTK package
 
 # Get and store all executable targets to DCMTKTargets.cmake within build's main dir
-GET_PROPERTY(DCMTK_EXECUTABLE_TARGETS GLOBAL PROPERTY DCMTK_EXECUTABLE_TARGETS)
-EXPORT(TARGETS ${DCMTK_EXECUTABLE_TARGETS} APPEND FILE "${DCMTK_BUILD_CMKDIR}/DCMTKTargets.cmake")
+get_property(DCMTK_EXECUTABLE_TARGETS GLOBAL PROPERTY DCMTK_EXECUTABLE_TARGETS)
+export(TARGETS ${DCMTK_EXECUTABLE_TARGETS} FILE "${DCMTK_BUILD_CMKDIR}/DCMTKTargets.cmake")
 
 # Get and store libraries to DCMTKTargets.cmake within the build's main dir
-GET_PROPERTY(DCMTK_LIBRARY_TARGETS GLOBAL PROPERTY DCMTK_LIBRARY_TARGETS)
-EXPORT(TARGETS ${DCMTK_LIBRARY_TARGETS} APPEND FILE "${DCMTK_BUILD_CMKDIR}/DCMTKTargets.cmake")
+get_property(DCMTK_LIBRARY_TARGETS GLOBAL PROPERTY DCMTK_LIBRARY_TARGETS)
+export(TARGETS ${DCMTK_LIBRARY_TARGETS} APPEND FILE "${DCMTK_BUILD_CMKDIR}/DCMTKTargets.cmake")
 
 # Create DCMTConfigVersion.cmake with basic DCMTK version information (build tree)
-SET(DCMTK_CONFIG_VERSION "${DCMTK_BUILD_CMKDIR}/DCMTKConfigVersion.cmake")
+set(DCMTK_CONFIG_VERSION "${DCMTK_BUILD_CMKDIR}/DCMTKConfigVersion.cmake")
 WRITE_BASIC_PACKAGE_VERSION_FILE(
     ${DCMTK_CONFIG_VERSION}
     VERSION ${DCMTK_MAJOR_VERSION}.${DCMTK_MINOR_VERSION}.${DCMTK_BUILD_VERSION}
@@ -36,46 +36,46 @@ WRITE_BASIC_PACKAGE_VERSION_FILE(
 # build and install tree versions of the file.
 
 # Case 1: Configure 'DCMTKConfig.cmake' for a build tree.
-SET(DCMTK_CMKDIR_CONFIG "${DCMTK_BUILD_CMKDIR}")
+set(DCMTK_CMKDIR_CONFIG "${DCMTK_BUILD_CMKDIR}")
 # Collect include paths
-SET(DCMTK_INCLUDE_DIR_CONFIGS
+set(DCMTK_INCLUDE_DIR_CONFIGS
     "SET_AND_CHECK(DCMTK_config_INCLUDE_DIR \"${DCMTK_BINARY_DIR}/config/include/dcmtk/config\")")
-FOREACH(module ${DCMTK_MODULES})
-    SET(DCMTK_INCLUDE_DIR_CONFIGS
+foreach(module ${DCMTK_MODULES})
+    set(DCMTK_INCLUDE_DIR_CONFIGS
         "${DCMTK_INCLUDE_DIR_CONFIGS}\nSET_AND_CHECK(DCMTK_${module}_INCLUDE_DIR \"${DCMTK_SOURCE_DIR}/${module}/include/dcmtk/${module}\")")
-ENDFOREACH(module)
-SET(DCMTK_CONFIG_CODE "####### Expanded from \@DCMTK_CONFIG_CODE\@ #######\n")
-SET(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"${DCMTK_BINARY_DIR}/config/include\")\n")
-FOREACH(module ${DCMTK_MODULES})
-    SET(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"${DCMTK_SOURCE_DIR}/${module}/include\")\n")
-ENDFOREACH(module)
-SET(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}##################################################")
-SET(dcmtk_config "${DCMTK_BUILD_CMKDIR}/DCMTKConfig.cmake")
+endforeach()
+set(DCMTK_CONFIG_CODE "####### Expanded from \@DCMTK_CONFIG_CODE\@ #######\n")
+set(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"${DCMTK_BINARY_DIR}/config/include\")\n")
+foreach(module ${DCMTK_MODULES})
+    set(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"${DCMTK_SOURCE_DIR}/${module}/include\")\n")
+endforeach()
+set(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}##################################################")
+set(dcmtk_config "${DCMTK_BUILD_CMKDIR}/DCMTKConfig.cmake")
 # Actually configure file and write it to build's main directory
 CONFIGURE_PACKAGE_CONFIG_FILE(
-    CMake/DCMTKConfig.cmake.in
+    ${DCMTK_SOURCE_DIR}/CMake/DCMTKConfig.cmake.in
     ${dcmtk_config}
     INSTALL_DESTINATION "${CMAKE_BINARY_DIR}"
     PATH_VARS DCMTK_CMKDIR_CONFIG DCMTK_INCLUDE_DIR_CONFIGS
     NO_CHECK_REQUIRED_COMPONENTS_MACRO)
 
 # Case 2: Configure 'DCMTKConfig.cmake' for an install tree
-SET(DCMTK_CMKDIR_CONFIG "${DCMTK_INSTALL_CMKDIR}")
+set(DCMTK_CMKDIR_CONFIG "${DCMTK_INSTALL_CMKDIR}")
 # Collect include paths
-SET(DCMTK_INCLUDE_DIR_CONFIGS
+set(DCMTK_INCLUDE_DIR_CONFIGS
     "SET_AND_CHECK(DCMTK_config_INCLUDE_DIR \"\${PACKAGE_PREFIX_DIR}/include/dcmtk/config\")")
-FOREACH(module ${DCMTK_MODULES})
-    SET(DCMTK_INCLUDE_DIR_CONFIGS
+foreach(module ${DCMTK_MODULES})
+    set(DCMTK_INCLUDE_DIR_CONFIGS
         "${DCMTK_INCLUDE_DIR_CONFIGS}\nSET_AND_CHECK(DCMTK_${module}_INCLUDE_DIR \"\${PACKAGE_PREFIX_DIR}/include/dcmtk/${module}\")")
-ENDFOREACH(module)
-SET(DCMTK_CONFIG_CODE "####### Expanded from \@DCMTK_CONFIG_CODE\@ #######\n")
-SET(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"\${PACKAGE_PREFIX_DIR}/include\")\n")
-SET(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}##################################################")
-SET(DCMTK_INSTALL_CONFIG "${CMAKE_BINARY_DIR}/CMakeFiles/DCMTKConfig.cmake")
+endforeach()
+set(DCMTK_CONFIG_CODE "####### Expanded from \@DCMTK_CONFIG_CODE\@ #######\n")
+set(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}list(APPEND DCMTK_INCLUDE_DIRS \"\${PACKAGE_PREFIX_DIR}/include\")\n")
+set(DCMTK_CONFIG_CODE "${DCMTK_CONFIG_CODE}##################################################")
+set(DCMTK_INSTALL_CONFIG "${CMAKE_BINARY_DIR}/CMakeFiles/DCMTKConfig.cmake")
 # Actually configure file and set rule to install it to installation subdir
 CONFIGURE_PACKAGE_CONFIG_FILE(
-    CMake/DCMTKConfig.cmake.in
+    ${DCMTK_SOURCE_DIR}/CMake/DCMTKConfig.cmake.in
     "${DCMTK_INSTALL_CONFIG}"
-    INSTALL_DESTINATION "${CMAKE_INSTALL_PREFIX}/${DCMTK_INSTALL_CMKDIR}"
+    INSTALL_DESTINATION "${DCMTK_INSTALL_CMKDIR}"
     PATH_VARS DCMTK_CMKDIR_CONFIG DCMTK_INCLUDE_DIR_CONFIGS
     NO_CHECK_REQUIRED_COMPONENTS_MACRO)

CMake/dcmtkAfterModules.cmake

 # Finish the setup. This should be run after all modules.
 
-IF(BUILD_SINGLE_SHARED_LIBRARY)
+if(BUILD_SINGLE_SHARED_LIBRARY)
   # Collect the object files of all libraries in all modules.
   # The variable ${DCMTK_ALL_LIBRARIES} is set by DCMTK_ADD_LIBRARY().
-  SET(LIBS)
-  FOREACH(LIB ${DCMTK_ALL_LIBRARIES})
-    SET(LIBS ${LIBS} $<TARGET_OBJECTS:${LIB}>)
-  ENDFOREACH(LIB)
+  set(LIBS)
+  foreach(LIB ${DCMTK_ALL_LIBRARIES})
+    set(LIBS ${LIBS} $<TARGET_OBJECTS:${LIB}>)
+  endforeach()
 
   # Build a single "everything-library".
   # The library dependencies are collected by DCMTK_TARGET_LINK_LIBRARIES().
-  ADD_LIBRARY(dcmtk SHARED ${LIBS})
-  TARGET_LINK_LIBRARIES(dcmtk ${DCMTK_LIBRARY_DEPENDENCIES})
-  SET_TARGET_PROPERTIES(dcmtk PROPERTIES ${DCMTK_LIBRARY_PROPERTIES})
+  add_library(dcmtk SHARED ${LIBS})
+  target_link_libraries(dcmtk ${DCMTK_LIBRARY_DEPENDENCIES})
+  set_target_properties(dcmtk PROPERTIES ${DCMTK_LIBRARY_PROPERTIES})
 
   # Export target for build tree
-  SET_PROPERTY(GLOBAL APPEND PROPERTY DCMTK_LIBRARY_TARGETS dcmtk)
+  set_property(GLOBAL APPEND PROPERTY DCMTK_LIBRARY_TARGETS dcmtk)
 
   # Declare installation files. Also export libs and executables to DCMTKTargets.cmake.
-  INSTALL(TARGETS dcmtk
+  install(TARGETS dcmtk
           EXPORT DCMTKTargets
           COMPONENT lib
           RUNTIME DESTINATION "${CMAKE_INSTALL_BINDIR}"
           LIBRARY DESTINATION "${CMAKE_INSTALL_LIBDIR}"
           ARCHIVE DESTINATION "${CMAKE_INSTALL_LIBDIR}")
-ENDIF(BUILD_SINGLE_SHARED_LIBRARY)
+endif()