diff options
484 files changed, 3224 insertions, 2893 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index 5336208..ae5990e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -67,7 +67,7 @@ if(NOT DEFINED CMAKE_CXX_STANDARD AND NOT CMake_NO_CXX_STANDARD) endif() endif() if(NOT CMake_TEST_EXTERNAL_CMAKE) - include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx11_unordered_map.cmake) + include(${CMake_SOURCE_DIR}/Source/Checks/cm_cxx_features.cmake) endif() # option to set the internal encoding of CMake to UTF-8 diff --git a/Help/manual/cmake-developer.7.rst b/Help/manual/cmake-developer.7.rst index 7bfdcad..afaccc6 100644 --- a/Help/manual/cmake-developer.7.rst +++ b/Help/manual/cmake-developer.7.rst @@ -24,9 +24,10 @@ to build with such toolchains. std::auto_ptr ------------- -Some implementations have a ``std::auto_ptr`` which can not be used as a -return value from a function. ``std::auto_ptr`` may not be used. Use -``cmsys::auto_ptr`` instead. +The ``std::auto_ptr`` template is deprecated in C++11. We want to use it +so we can build on C++98 compilers but we do not want to turn off compiler +warnings about deprecated interfaces in general. Use the ``CM_AUTO_PTR`` +macro instead. size_t ------ diff --git a/Help/manual/cmake-policies.7.rst b/Help/manual/cmake-policies.7.rst index 43f4637..0cfe983 100644 --- a/Help/manual/cmake-policies.7.rst +++ b/Help/manual/cmake-policies.7.rst @@ -51,6 +51,14 @@ The :variable:`CMAKE_MINIMUM_REQUIRED_VERSION` variable may also be used to determine whether to report an error on use of deprecated macros or functions. +Policies Introduced by CMake 3.7 +================================ + +.. toctree:: + :maxdepth: 1 + + CMP0066: Honor per-config flags in try_compile() source-file signature. </policy/CMP0066> + Policies Introduced by CMake 3.4 ================================ diff --git a/Help/policy/CMP0066.rst b/Help/policy/CMP0066.rst new file mode 100644 index 0000000..d1dcb0e --- /dev/null +++ b/Help/policy/CMP0066.rst @@ -0,0 +1,27 @@ +CMP0066 +------- + +Honor per-config flags in :command:`try_compile` source-file signature. + +The source file signature of the :command:`try_compile` command uses the value +of the :variable:`CMAKE_<LANG>_FLAGS` variable in the test project so that the +test compilation works as it would in the main project. However, CMake 3.6 and +below do not also honor config-specific compiler flags such as those in the +:variable:`CMAKE_<LANG>_FLAGS_DEBUG` variable. CMake 3.7 and above prefer to +honor config-specific compiler flags too. This policy provides compatibility +for projects that do not expect config-specific compiler flags to be used. + +The ``OLD`` behavior of this policy is to ignore config-specific flag +variables like :variable:`CMAKE_<LANG>_FLAGS_DEBUG` and only use CMake's +built-in defaults for the current compiler and platform. + +The ``NEW`` behavior of this policy is to honor config-specific flag +variabldes like :variable:`CMAKE_<LANG>_FLAGS_DEBUG`. + +This policy was introduced in CMake version 3.7. Unlike most policies, +CMake version |release| does *not* warn by default when this policy +is not set and simply uses OLD behavior. See documentation of the +:variable:`CMAKE_POLICY_WARNING_CMP0066 <CMAKE_POLICY_WARNING_CMP<NNNN>>` +variable to control the warning. + +.. include:: DEPRECATED.txt diff --git a/Help/prop_tgt/CXX_EXTENSIONS.rst b/Help/prop_tgt/CXX_EXTENSIONS.rst index 0f547e2..280bb3a 100644 --- a/Help/prop_tgt/CXX_EXTENSIONS.rst +++ b/Help/prop_tgt/CXX_EXTENSIONS.rst @@ -6,7 +6,8 @@ Boolean specifying whether compiler specific extensions are requested. This property specifies whether compiler specific extensions should be used. For some compilers, this results in adding a flag such as ``-std=gnu++11`` instead of ``-std=c++11`` to the compile line. This -property is ``ON`` by default. +property is ``ON`` by default. The basic C++ standard level is +controlled by the :prop_tgt:`CXX_STANDARD` target property. See the :manual:`cmake-compile-features(7)` manual for information on compile features and a list of supported compilers. diff --git a/Help/prop_tgt/CXX_STANDARD.rst b/Help/prop_tgt/CXX_STANDARD.rst index edc9ba5..5b186c1 100644 --- a/Help/prop_tgt/CXX_STANDARD.rst +++ b/Help/prop_tgt/CXX_STANDARD.rst @@ -22,6 +22,8 @@ with a compiler which does not support ``-std=gnu++11`` or an equivalent flag will not result in an error or warning, but will instead add the ``-std=gnu++98`` flag if supported. This "decay" behavior may be controlled with the :prop_tgt:`CXX_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`CXX_EXTENSIONS` target property may be used to +control whether compiler-specific extensions are enabled on a per-target basis. See the :manual:`cmake-compile-features(7)` manual for information on compile features and a list of supported compilers. diff --git a/Help/prop_tgt/C_EXTENSIONS.rst b/Help/prop_tgt/C_EXTENSIONS.rst index fce67f4..05b14ce 100644 --- a/Help/prop_tgt/C_EXTENSIONS.rst +++ b/Help/prop_tgt/C_EXTENSIONS.rst @@ -6,7 +6,8 @@ Boolean specifying whether compiler specific extensions are requested. This property specifies whether compiler specific extensions should be used. For some compilers, this results in adding a flag such as ``-std=gnu11`` instead of ``-std=c11`` to the compile line. This -property is ``ON`` by default. +property is ``ON`` by default. The basic C standard level is +controlled by the :prop_tgt:`C_STANDARD` target property. See the :manual:`cmake-compile-features(7)` manual for information on compile features and a list of supported compilers. diff --git a/Help/prop_tgt/C_STANDARD.rst b/Help/prop_tgt/C_STANDARD.rst index 5e36821..815a686 100644 --- a/Help/prop_tgt/C_STANDARD.rst +++ b/Help/prop_tgt/C_STANDARD.rst @@ -22,6 +22,8 @@ with a compiler which does not support ``-std=gnu11`` or an equivalent flag will not result in an error or warning, but will instead add the ``-std=gnu99`` or ``-std=gnu90`` flag if supported. This "decay" behavior may be controlled with the :prop_tgt:`C_STANDARD_REQUIRED` target property. +Additionally, the :prop_tgt:`C_EXTENSIONS` target property may be used to +control whether compiler-specific extensions are enabled on a per-target basis. See the :manual:`cmake-compile-features(7)` manual for information on compile features and a list of supported compilers. diff --git a/Help/prop_tgt/FRAMEWORK.rst b/Help/prop_tgt/FRAMEWORK.rst index 6c212c3..8120c36 100644 --- a/Help/prop_tgt/FRAMEWORK.rst +++ b/Help/prop_tgt/FRAMEWORK.rst @@ -26,6 +26,10 @@ Example of creation ``dynamicFramework``: FRAMEWORK_VERSION C MACOSX_FRAMEWORK_IDENTIFIER com.cmake.dynamicFramework MACOSX_FRAMEWORK_INFO_PLIST Info.plist + # "current version" in semantic format in Mach-O binary file + VERSION 16.4.0 + # "compatibility version" in semantic format in Mach-O binary file + SOVERSION 1.0.0 PUBLIC_HEADER dynamicFramework.h XCODE_ATTRIBUTE_CODE_SIGN_IDENTITY "iPhone Developer" ) diff --git a/Help/prop_tgt/SOVERSION.rst b/Help/prop_tgt/SOVERSION.rst index 672ff23..82b6b97 100644 --- a/Help/prop_tgt/SOVERSION.rst +++ b/Help/prop_tgt/SOVERSION.rst @@ -3,12 +3,25 @@ SOVERSION What version number is this target. -For shared libraries VERSION and SOVERSION can be used to specify the -build version and API version respectively. When building or +For shared libraries :prop_tgt:`VERSION` and ``SOVERSION`` can be used to +specify the build version and API version respectively. When building or installing appropriate symlinks are created if the platform supports symlinks and the linker supports so-names. If only one of both is specified the missing is assumed to have the same version number. -SOVERSION is ignored if NO_SONAME property is set. For shared -libraries and executables on Windows the VERSION attribute is parsed -to extract a "major.minor" version number. These numbers are used as -the image version of the binary. +``SOVERSION`` is ignored if :prop_tgt:`NO_SONAME` property is set. + +Windows Versions +^^^^^^^^^^^^^^^^ + +For shared libraries and executables on Windows the :prop_tgt:`VERSION` +attribute is parsed to extract a ``<major>.<minor>`` version number. +These numbers are used as the image version of the binary. + +Mach-O Versions +^^^^^^^^^^^^^^^ + +For shared libraries and executables on Mach-O systems (e.g. OS X, iOS), +the ``SOVERSION`` property corresponds to *compatibility version* and +:prop_tgt:`VERSION` to *current version*. See the :prop_tgt:`FRAMEWORK` target +property for an example. Versions of Mach-O binaries may be checked with the +``otool -L <binary>`` command. diff --git a/Help/prop_tgt/VERSION.rst b/Help/prop_tgt/VERSION.rst index 87f6c49..66e7bde 100644 --- a/Help/prop_tgt/VERSION.rst +++ b/Help/prop_tgt/VERSION.rst @@ -3,14 +3,27 @@ VERSION What version number is this target. -For shared libraries VERSION and SOVERSION can be used to specify the -build version and API version respectively. When building or +For shared libraries ``VERSION`` and :prop_tgt:`SOVERSION` can be used +to specify the build version and API version respectively. When building or installing appropriate symlinks are created if the platform supports symlinks and the linker supports so-names. If only one of both is specified the missing is assumed to have the same version number. For -executables VERSION can be used to specify the build version. When +executables ``VERSION`` can be used to specify the build version. When building or installing appropriate symlinks are created if the -platform supports symlinks. For shared libraries and executables on -Windows the VERSION attribute is parsed to extract a "major.minor" -version number. These numbers are used as the image version of the -binary. +platform supports symlinks. + +Windows Versions +^^^^^^^^^^^^^^^^ + +For shared libraries and executables on Windows the ``VERSION`` +attribute is parsed to extract a ``<major>.<minor>`` version number. +These numbers are used as the image version of the binary. + +Mach-O Versions +^^^^^^^^^^^^^^^ + +For shared libraries and executables on Mach-O systems (e.g. OS X, iOS), +the :prop_tgt:`SOVERSION` property correspond to *compatibility version* and +``VERSION`` to *current version*. See the :prop_tgt:`FRAMEWORK` target +property for an example. Versions of Mach-O binaries may be checked with the +``otool -L <binary>`` command. diff --git a/Help/release/3.6.rst b/Help/release/3.6.rst index 5c08b39..771c9dd 100644 --- a/Help/release/3.6.rst +++ b/Help/release/3.6.rst @@ -42,11 +42,6 @@ Commands commands gained support for the ``%s`` placeholder. This is the number of seconds since the UNIX Epoch. -* The :command:`try_compile` command source file signature now honors - configuration-specific flags (e.g. :variable:`CMAKE_<LANG>_FLAGS_DEBUG`) - in the generated test project. Previously only the default such flags - for the current toolchain were used. - Variables --------- diff --git a/Help/release/dev/GenerateExportHeader-custom-content.rst b/Help/release/dev/GenerateExportHeader-custom-content.rst new file mode 100644 index 0000000..161261c --- /dev/null +++ b/Help/release/dev/GenerateExportHeader-custom-content.rst @@ -0,0 +1,6 @@ +GenerateExportHeader-custom-content +----------------------------------- + +* The :module:`GenerateExportHeader` module learned a new + ``CUSTOM_CONTENT_FROM_VARIABLE`` option to specify a variable + containing custom content for inclusion in the generated header. diff --git a/Help/release/dev/try_compile-config-flags.rst b/Help/release/dev/try_compile-config-flags.rst new file mode 100644 index 0000000..ebfd6a4 --- /dev/null +++ b/Help/release/dev/try_compile-config-flags.rst @@ -0,0 +1,7 @@ +try_compile-config-flags +------------------------ + +* The :command:`try_compile` command source file signature now honors + configuration-specific flags (e.g. :variable:`CMAKE_<LANG>_FLAGS_DEBUG`) + in the generated test project. Previously only the default such flags + for the current toolchain were used. See policy :policy:`CMP0066`. diff --git a/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst b/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst index 582f9e4..36cf75f 100644 --- a/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst +++ b/Help/variable/CMAKE_POLICY_WARNING_CMPNNNN.rst @@ -15,6 +15,8 @@ warn by default: policy :policy:`CMP0060`. * ``CMAKE_POLICY_WARNING_CMP0065`` controls the warning for policy :policy:`CMP0065`. +* ``CMAKE_POLICY_WARNING_CMP0066`` controls the warning for + policy :policy:`CMP0066`. This variable should not be set by a project in CMake code. Project developers running CMake may set this variable in their cache to diff --git a/Help/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES.rst b/Help/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES.rst index 8e43465..0f96787 100644 --- a/Help/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES.rst +++ b/Help/variable/CMAKE_TRY_COMPILE_PLATFORM_VARIABLES.rst @@ -8,3 +8,19 @@ the host project. This variable should not be set by project code. It is meant to be set by CMake's platform information modules for the current toolchain, or by a toolchain file when used with :variable:`CMAKE_TOOLCHAIN_FILE`. + +Variables meaningful to CMake, such as :variable:`CMAKE_<LANG>_FLAGS`, are +propagated automatically. The ``CMAKE_TRY_COMPILE_PLATFORM_VARIABLES`` +variable may be set to pass custom variables meaningful to a toolchain file. +For example, a toolchain file may contain: + +.. code-block:: cmake + + set(CMAKE_SYSTEM_NAME ...) + set(CMAKE_TRY_COMPILE_PLATFORM_VARIABLES MY_CUSTOM_VARIABLE) + # ... use MY_CUSTOM_VARIABLE ... + +If a user passes ``-DMY_CUSTOM_VARIABLE=SomeValue`` to CMake then this +setting will be made visible to the toolchain file both for the main +project and for test projects generated by the :command:`try_compile` +command source file signature. diff --git a/Modules/CMakeASMInformation.cmake b/Modules/CMakeASMInformation.cmake index 0e547c4..1bb16ac 100644 --- a/Modules/CMakeASMInformation.cmake +++ b/Modules/CMakeASMInformation.cmake @@ -76,10 +76,11 @@ endif() # Support for CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT and friends: set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT "$ENV{ASM${ASM_DIALECT}FLAGS} ${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}") -# avoid just having a space as the initial value for the cache -if(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT STREQUAL " ") - set(CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT) -endif() + +foreach(c "" _DEBUG _RELEASE _MINSIZEREL _RELWITHDEBINFO) + string(STRIP "${CMAKE_ASM${ASM_DIALECT}_FLAGS${c}_INIT}" CMAKE_ASM${ASM_DIALECT}_FLAGS${c}_INIT) +endforeach() + set (CMAKE_ASM${ASM_DIALECT}_FLAGS "${CMAKE_ASM${ASM_DIALECT}_FLAGS_INIT}" CACHE STRING "Flags used by the assembler during all build types.") diff --git a/Modules/CMakeCInformation.cmake b/Modules/CMakeCInformation.cmake index fa87ca8..98eedc4 100644 --- a/Modules/CMakeCInformation.cmake +++ b/Modules/CMakeCInformation.cmake @@ -111,10 +111,11 @@ if(NOT CMAKE_MODULE_EXISTS) endif() set(CMAKE_C_FLAGS_INIT "$ENV{CFLAGS} ${CMAKE_C_FLAGS_INIT}") -# avoid just having a space as the initial value for the cache -if(CMAKE_C_FLAGS_INIT STREQUAL " ") - set(CMAKE_C_FLAGS_INIT) -endif() + +foreach(c "" _DEBUG _RELEASE _MINSIZEREL _RELWITHDEBINFO) + string(STRIP "${CMAKE_C_FLAGS${c}_INIT}" CMAKE_C_FLAGS${c}_INIT) +endforeach() + set (CMAKE_C_FLAGS "${CMAKE_C_FLAGS_INIT}" CACHE STRING "Flags used by the compiler during all build types.") diff --git a/Modules/CMakeCXXInformation.cmake b/Modules/CMakeCXXInformation.cmake index b35280f..07e4f39 100644 --- a/Modules/CMakeCXXInformation.cmake +++ b/Modules/CMakeCXXInformation.cmake @@ -206,10 +206,11 @@ endforeach() # use _INIT variables so that this only happens the first time # and you can set these flags in the cmake cache set(CMAKE_CXX_FLAGS_INIT "$ENV{CXXFLAGS} ${CMAKE_CXX_FLAGS_INIT}") -# avoid just having a space as the initial value for the cache -if(CMAKE_CXX_FLAGS_INIT STREQUAL " ") - set(CMAKE_CXX_FLAGS_INIT) -endif() + +foreach(c "" _DEBUG _RELEASE _MINSIZEREL _RELWITHDEBINFO) + string(STRIP "${CMAKE_CXX_FLAGS${c}_INIT}" CMAKE_CXX_FLAGS${c}_INIT) +endforeach() + set (CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS_INIT}" CACHE STRING "Flags used by the compiler during all build types.") diff --git a/Modules/CMakeFortranInformation.cmake b/Modules/CMakeFortranInformation.cmake index 1fd0972..45dbfcc 100644 --- a/Modules/CMakeFortranInformation.cmake +++ b/Modules/CMakeFortranInformation.cmake @@ -173,10 +173,11 @@ endif() set(CMAKE_VERBOSE_MAKEFILE FALSE CACHE BOOL "If this value is on, makefiles will be generated without the .SILENT directive, and all commands will be echoed to the console during the make. This is useful for debugging only. With Visual Studio IDE projects all commands are done without /nologo.") set(CMAKE_Fortran_FLAGS_INIT "$ENV{FFLAGS} ${CMAKE_Fortran_FLAGS_INIT}") -# avoid just having a space as the initial value for the cache -if(CMAKE_Fortran_FLAGS_INIT STREQUAL " ") - set(CMAKE_Fortran_FLAGS_INIT) -endif() + +foreach(c "" _DEBUG _RELEASE _MINSIZEREL _RELWITHDEBINFO) + string(STRIP "${CMAKE_Fortran_FLAGS${c}_INIT}" CMAKE_Fortran_FLAGS${c}_INIT) +endforeach() + set (CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS_INIT}" CACHE STRING "Flags for Fortran compiler.") diff --git a/Modules/CMakeIOSInstallCombined.cmake b/Modules/CMakeIOSInstallCombined.cmake index 1256f56..234322c 100644 --- a/Modules/CMakeIOSInstallCombined.cmake +++ b/Modules/CMakeIOSInstallCombined.cmake @@ -237,20 +237,30 @@ function(ios_install_combined target destination) endif() set(cmd xcrun -f lipo) + + # Do not merge OUTPUT_VARIABLE and ERROR_VARIABLE since latter may contain + # some diagnostic information even for the successful run. execute_process( COMMAND ${cmd} RESULT_VARIABLE result OUTPUT_VARIABLE output - ERROR_VARIABLE output + ERROR_VARIABLE error_output OUTPUT_STRIP_TRAILING_WHITESPACE ERROR_STRIP_TRAILING_WHITESPACE ) if(NOT result EQUAL 0) message( - FATAL_ERROR "Command failed (${result}): ${cmd}\n\nOutput:\n${output}" + FATAL_ERROR "Command failed (${result}): ${cmd}\n\nOutput:\n${output}\nOutput(error):\n${error_output}" ) endif() set(_lipo_path ${output}) + list(LENGTH _lipo_path len) + if(NOT len EQUAL 1) + message(FATAL_ERROR "Unexpected xcrun output: ${_lipo_path}") + endif() + if(NOT EXISTS "${_lipo_path}") + message(FATAL_ERROR "File not found: ${_lipo_path}") + endif() set(CURRENT_CONFIG "${CMAKE_INSTALL_CONFIG_NAME}") set(CURRENT_TARGET "${target}") diff --git a/Modules/CMakeRCInformation.cmake b/Modules/CMakeRCInformation.cmake index 94abd4b..60276e2 100644 --- a/Modules/CMakeRCInformation.cmake +++ b/Modules/CMakeRCInformation.cmake @@ -28,9 +28,9 @@ set(CMAKE_SYSTEM_AND_RC_COMPILER_INFO_FILE ${CMAKE_ROOT}/Modules/Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME}.cmake) include(Platform/${CMAKE_SYSTEM_NAME}-${CMAKE_BASE_NAME} OPTIONAL) +string(STRIP "$ENV{RCFLAGS} ${CMAKE_RC_FLAGS_INIT}" CMAKE_RC_FLAGS_INIT) - -set (CMAKE_RC_FLAGS "$ENV{RCFLAGS} ${CMAKE_RC_FLAGS_INIT}" CACHE STRING +set (CMAKE_RC_FLAGS "${CMAKE_RC_FLAGS_INIT}" CACHE STRING "Flags for Windows Resource Compiler.") # These are the only types of flags that should be passed to the rc diff --git a/Modules/CPackComponent.cmake b/Modules/CPackComponent.cmake index 038a717..6a33086 100644 --- a/Modules/CPackComponent.cmake +++ b/Modules/CPackComponent.cmake @@ -360,6 +360,20 @@ macro(cpack_append_string_variable_set_command var strvar) endif () endmacro() +# Macro that appends a SET command for the given list variable name (var) +# to the macro named strvar, but only if the variable named "var" +# has been defined. It's like add variable, but wrap each item to quotes. +# The string will eventually be appended to a CPack configuration file. +macro(cpack_append_list_variable_set_command var strvar) + if (DEFINED ${var}) + string(APPEND ${strvar} "set(${var}") + foreach(_val IN LISTS ${var}) + string(APPEND ${strvar} "\n \"${_val}\"") + endforeach() + string(APPEND ${strvar} ")\n") + endif () +endmacro() + # Macro that appends a SET command for the given variable name (var) # to the macro named strvar, but only if the variable named "var" # has been set to true. The string will eventually be diff --git a/Modules/CPackIFW.cmake b/Modules/CPackIFW.cmake index 083fc28..2f0e03e 100644 --- a/Modules/CPackIFW.cmake +++ b/Modules/CPackIFW.cmake @@ -571,7 +571,7 @@ macro(cpack_ifw_configure_component compname) endforeach() foreach(_IFW_ARG_NAME ${_IFW_MULTI_ARGS}) - cpack_append_variable_set_command( + cpack_append_list_variable_set_command( CPACK_IFW_COMPONENT_${_CPACK_IFWCOMP_UNAME}_${_IFW_ARG_NAME} _CPACK_IFWCOMP_STR) endforeach() @@ -604,7 +604,7 @@ macro(cpack_ifw_configure_component_group grpname) endforeach() foreach(_IFW_ARG_NAME ${_IFW_MULTI_ARGS}) - cpack_append_variable_set_command( + cpack_append_list_variable_set_command( CPACK_IFW_COMPONENT_GROUP_${_CPACK_IFWGRP_UNAME}_${_IFW_ARG_NAME} _CPACK_IFWGRP_STR) endforeach() diff --git a/Modules/FindHDF5.cmake b/Modules/FindHDF5.cmake index bc0d50b..b074f63 100644 --- a/Modules/FindHDF5.cmake +++ b/Modules/FindHDF5.cmake @@ -362,20 +362,35 @@ if(NOT HDF5_FOUND AND NOT HDF5_ROOT) set(_suffix "-shared") endif() foreach(_lang ${HDF5_LANGUAGE_BINDINGS}) - get_target_property(_lang_location ${HDF5_${_component}_TARGET}${_suffix} LOCATION) + + #Older versions of hdf5 don't have a static/shared suffix so + #if we detect that occurrence clear the suffix + if(_suffix AND NOT TARGET ${HDF5_${_lang}_TARGET}${_suffix}) + if(NOT TARGET ${HDF5_${_lang}_TARGET}) + #cant find this component with our without the suffix + #so bail out, and let the following locate HDF5 + set(HDF5_FOUND FALSE) + break() + endif() + set(_suffix "") + endif() + + get_target_property(_lang_location ${HDF5_${_lang}_TARGET}${_suffix} LOCATION) if( _lang_location ) set(HDF5_${_lang}_LIBRARY ${_lang_location} CACHE PATH "HDF5 ${_lang} library" ) mark_as_advanced(HDF5_${_lang}_LIBRARY) list(APPEND HDF5_LIBRARIES ${HDF5_${_lang}_LIBRARY}) + set(HDF5_${_lang}_LIBRARIES ${HDF5_${_lang}_LIBRARY}) endif() if(FIND_HL) get_target_property(_lang_hl_location ${HDF5_${_lang}_HL_TARGET}${_suffix} LOCATION) - if( _lang_location ) - set(HDF5_${_lang}_HL_LIBRARY ${_lang_location} CACHE PATH + if( _lang_hl_location ) + set(HDF5_${_lang}_HL_LIBRARY ${_lang_hl_location} CACHE PATH "HDF5 ${_lang} HL library" ) - mark_as_advanced(HDF5_${_lang}_LIBRARY) + mark_as_advanced(HDF5_${_lang}_HL_LIBRARY) list(APPEND HDF5_HL_LIBRARIES ${HDF5_${_lang}_HL_LIBRARY}) + set(HDF5_${_lang}_HL_LIBRARIES ${HDF5_${_lang}_HL_LIBRARY}) endif() endif() endforeach() @@ -411,6 +426,8 @@ if(NOT HDF5_FOUND AND NOT HDF5_ROOT) set(HDF5_${__lang}_DEFINITIONS) set(HDF5_${__lang}_INCLUDE_DIRS) set(HDF5_${__lang}_LIBRARIES) + set(HDF5_${__lang}_HL_LIBRARIES) + mark_as_advanced(HDF5_${__lang}_COMPILER_EXECUTABLE_NO_INTERROGATE) mark_as_advanced(HDF5_${__lang}_DEFINITIONS) mark_as_advanced(HDF5_${__lang}_INCLUDE_DIRS) diff --git a/Modules/GenerateExportHeader.cmake b/Modules/GenerateExportHeader.cmake index 6389d30..6205b8c 100644 --- a/Modules/GenerateExportHeader.cmake +++ b/Modules/GenerateExportHeader.cmake @@ -20,6 +20,7 @@ # [NO_DEPRECATED_MACRO_NAME <no_deprecated_macro_name>] # [DEFINE_NO_DEPRECATED] # [PREFIX_NAME <prefix_name>] +# [CUSTOM_CONTENT_FROM_VARIABLE <variable>] # ) # # @@ -60,8 +61,10 @@ # The CMake fragment will generate a file in the # ``${CMAKE_CURRENT_BINARY_DIR}`` called ``somelib_export.h`` containing the # macros ``SOMELIB_EXPORT``, ``SOMELIB_NO_EXPORT``, ``SOMELIB_DEPRECATED``, -# ``SOMELIB_DEPRECATED_EXPORT`` and ``SOMELIB_DEPRECATED_NO_EXPORT``. The -# resulting file should be installed with other headers in the library. +# ``SOMELIB_DEPRECATED_EXPORT`` and ``SOMELIB_DEPRECATED_NO_EXPORT``. +# They will be followed by content taken from the variable specified by +# the ``CUSTOM_CONTENT_FROM_VARIABLE`` option, if any. +# The resulting file should be installed with other headers in the library. # # The ``BASE_NAME`` argument can be used to override the file name and the # names used for the macros: @@ -288,7 +291,7 @@ macro(_DO_GENERATE_EXPORT_HEADER TARGET_LIBRARY) set(options DEFINE_NO_DEPRECATED) set(oneValueArgs PREFIX_NAME BASE_NAME EXPORT_MACRO_NAME EXPORT_FILE_NAME DEPRECATED_MACRO_NAME NO_EXPORT_MACRO_NAME STATIC_DEFINE - NO_DEPRECATED_MACRO_NAME) + NO_DEPRECATED_MACRO_NAME CUSTOM_CONTENT_FROM_VARIABLE) set(multiValueArgs) cmake_parse_arguments(_GEH "${options}" "${oneValueArgs}" "${multiValueArgs}" @@ -361,6 +364,14 @@ macro(_DO_GENERATE_EXPORT_HEADER TARGET_LIBRARY) endif() string(MAKE_C_IDENTIFIER ${EXPORT_IMPORT_CONDITION} EXPORT_IMPORT_CONDITION) + if(_GEH_CUSTOM_CONTENT_FROM_VARIABLE) + if(DEFINED "${_GEH_CUSTOM_CONTENT_FROM_VARIABLE}") + set(CUSTOM_CONTENT "${${_GEH_CUSTOM_CONTENT_FROM_VARIABLE}}") + else() + set(CUSTOM_CONTENT "") + endif() + endif() + configure_file("${_GENERATE_EXPORT_HEADER_MODULE_DIR}/exportheader.cmake.in" "${EXPORT_FILE_NAME}" @ONLY) endmacro() diff --git a/Modules/GetPrerequisites.cmake b/Modules/GetPrerequisites.cmake index 1981040..631220b 100644 --- a/Modules/GetPrerequisites.cmake +++ b/Modules/GetPrerequisites.cmake @@ -746,7 +746,7 @@ function(get_prerequisites target prerequisites_var exclude_system recurse exepa set(gp_regex_error "") set(gp_regex_fallback "") set(gp_regex_cmp_count 1) - # objdump generaates copious output so we create a grep filter to pre-filter results + # objdump generates copious output so we create a grep filter to pre-filter results if(WIN32) find_program(gp_grep_cmd findstr) else() diff --git a/Modules/InstallRequiredSystemLibraries.cmake b/Modules/InstallRequiredSystemLibraries.cmake index aa84077..1c6e751 100644 --- a/Modules/InstallRequiredSystemLibraries.cmake +++ b/Modules/InstallRequiredSystemLibraries.cmake @@ -25,8 +25,8 @@ # # ``CMAKE_INSTALL_UCRT_LIBRARIES`` # Set to TRUE to install the Windows Universal CRT libraries for -# app-local deployment. This is meaningful only with MSVC from -# Visual Studio 2015 or higher. +# app-local deployment (e.g. to Windows XP). This is meaningful +# only with MSVC from Visual Studio 2015 or higher. # # ``CMAKE_INSTALL_MFC_LIBRARIES`` # Set to TRUE to install the MSVC MFC runtime libraries. diff --git a/Modules/exportheader.cmake.in b/Modules/exportheader.cmake.in index 7cfbcbd..9dd75bf 100644 --- a/Modules/exportheader.cmake.in +++ b/Modules/exportheader.cmake.in @@ -38,5 +38,5 @@ # define @NO_DEPRECATED_MACRO_NAME@ # endif #endif - +@CUSTOM_CONTENT@ #endif diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index fd73984..d49ebbb 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -364,6 +364,7 @@ set(SRCS cmake.cxx cmake.h + cm_auto_ptr.hxx cm_get_date.h cm_get_date.c cm_sha2.h diff --git a/Source/CMakeVersion.cmake b/Source/CMakeVersion.cmake index 40f8e11..98a00a8 100644 --- a/Source/CMakeVersion.cmake +++ b/Source/CMakeVersion.cmake @@ -1,5 +1,5 @@ # CMake version number components. set(CMake_VERSION_MAJOR 3) set(CMake_VERSION_MINOR 6) -set(CMake_VERSION_PATCH 20160624) +set(CMake_VERSION_PATCH 20160706) #set(CMake_VERSION_RC 1) diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.cxx b/Source/CPack/IFW/cmCPackIFWGenerator.cxx index accba08..4a5eb90 100644 --- a/Source/CPack/IFW/cmCPackIFWGenerator.cxx +++ b/Source/CPack/IFW/cmCPackIFWGenerator.cxx @@ -101,8 +101,9 @@ int cmCPackIFWGenerator::PackageFiles() int retVal = 1; cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate repository" << std::endl); - bool res = cmSystemTools::RunSingleCommand( - ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0); + bool res = cmSystemTools::RunSingleCommand(ifwCmd.c_str(), &output, + &output, &retVal, CM_NULLPTR, + this->GeneratorVerbose, 0); if (!res || retVal) { cmGeneratedFileStream ofs(ifwTmpFile.c_str()); ofs << "# Run command: " << ifwCmd << std::endl @@ -178,8 +179,9 @@ int cmCPackIFWGenerator::PackageFiles() std::string output; int retVal = 1; cmCPackLogger(cmCPackLog::LOG_OUTPUT, "- Generate package" << std::endl); - bool res = cmSystemTools::RunSingleCommand( - ifwCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0); + bool res = cmSystemTools::RunSingleCommand(ifwCmd.c_str(), &output, + &output, &retVal, CM_NULLPTR, + this->GeneratorVerbose, 0); if (!res || retVal) { cmGeneratedFileStream ofs(ifwTmpFile.c_str()); ofs << "# Run command: " << ifwCmd << std::endl @@ -526,7 +528,7 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetGroupPackage( { std::map<cmCPackComponentGroup*, cmCPackIFWPackage*>::const_iterator pit = GroupPackages.find(group); - return pit != GroupPackages.end() ? pit->second : 0; + return pit != GroupPackages.end() ? pit->second : CM_NULLPTR; } cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage( @@ -534,7 +536,7 @@ cmCPackIFWPackage* cmCPackIFWGenerator::GetComponentPackage( { std::map<cmCPackComponent*, cmCPackIFWPackage*>::const_iterator pit = ComponentPackages.find(component); - return pit != ComponentPackages.end() ? pit->second : 0; + return pit != ComponentPackages.end() ? pit->second : CM_NULLPTR; } cmCPackIFWRepository* cmCPackIFWGenerator::GetRepository( @@ -556,7 +558,7 @@ cmCPackIFWRepository* cmCPackIFWGenerator::GetRepository( } } else { Repositories.erase(repositoryName); - repository = 0; + repository = CM_NULLPTR; cmCPackLogger(cmCPackLog::LOG_WARNING, "Invalid repository \"" << repositoryName << "\"" << " configuration. Repository will be skipped." diff --git a/Source/CPack/IFW/cmCPackIFWGenerator.h b/Source/CPack/IFW/cmCPackIFWGenerator.h index 2b35749..12f2ca6 100644 --- a/Source/CPack/IFW/cmCPackIFWGenerator.h +++ b/Source/CPack/IFW/cmCPackIFWGenerator.h @@ -46,7 +46,7 @@ public: /** * Destruct IFW generator */ - virtual ~cmCPackIFWGenerator(); + ~cmCPackIFWGenerator() CM_OVERRIDE; /** * Compare \a version with QtIFW framework version @@ -70,18 +70,18 @@ protected: * @brief Initialize generator * @return 0 on failure */ - virtual int InitializeInternal(); - virtual int PackageFiles(); - virtual const char* GetPackagingInstallPrefix(); + int InitializeInternal() CM_OVERRIDE; + int PackageFiles() CM_OVERRIDE; + const char* GetPackagingInstallPrefix() CM_OVERRIDE; /** * @brief Extension of binary installer * @return Executable suffix or value from default implementation */ - virtual const char* GetOutputExtension(); + const char* GetOutputExtension() CM_OVERRIDE; - virtual std::string GetComponentInstallDirNameSuffix( - const std::string& componentName); + std::string GetComponentInstallDirNameSuffix( + const std::string& componentName) CM_OVERRIDE; /** * @brief Get Component @@ -92,8 +92,8 @@ protected: * * @return Pointer to component */ - virtual cmCPackComponent* GetComponent(const std::string& projectName, - const std::string& componentName); + cmCPackComponent* GetComponent(const std::string& projectName, + const std::string& componentName) CM_OVERRIDE; /** * @brief Get group of component @@ -104,12 +104,13 @@ protected: * * @return Pointer to component group */ - virtual cmCPackComponentGroup* GetComponentGroup( - const std::string& projectName, const std::string& groupName); + cmCPackComponentGroup* GetComponentGroup( + const std::string& projectName, const std::string& groupName) CM_OVERRIDE; - enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const; - virtual bool SupportsAbsoluteDestination() const; - virtual bool SupportsComponentInstallation() const; + enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const + CM_OVERRIDE; + bool SupportsAbsoluteDestination() const CM_OVERRIDE; + bool SupportsComponentInstallation() const CM_OVERRIDE; protected: // Methods diff --git a/Source/CPack/IFW/cmCPackIFWInstaller.cxx b/Source/CPack/IFW/cmCPackIFWInstaller.cxx index 74f6da6..13a3613 100644 --- a/Source/CPack/IFW/cmCPackIFWInstaller.cxx +++ b/Source/CPack/IFW/cmCPackIFWInstaller.cxx @@ -33,13 +33,13 @@ } while (0) cmCPackIFWInstaller::cmCPackIFWInstaller() - : Generator(0) + : Generator(CM_NULLPTR) { } const char* cmCPackIFWInstaller::GetOption(const std::string& op) const { - return Generator ? Generator->GetOption(op) : 0; + return Generator ? Generator->GetOption(op) : CM_NULLPTR; } bool cmCPackIFWInstaller::IsOn(const std::string& op) const diff --git a/Source/CPack/IFW/cmCPackIFWPackage.cxx b/Source/CPack/IFW/cmCPackIFWPackage.cxx index 405d668..5db06e6 100644 --- a/Source/CPack/IFW/cmCPackIFWPackage.cxx +++ b/Source/CPack/IFW/cmCPackIFWPackage.cxx @@ -96,15 +96,15 @@ std::string cmCPackIFWPackage::DependenceStruct::NameWithCompare() const //------------------------------------------------------ cmCPackIFWPackage --- cmCPackIFWPackage::cmCPackIFWPackage() - : Generator(0) - , Installer(0) + : Generator(CM_NULLPTR) + , Installer(CM_NULLPTR) { } const char* cmCPackIFWPackage::GetOption(const std::string& op) const { - const char* option = Generator ? Generator->GetOption(op) : 0; - return option && *option ? option : 0; + const char* option = Generator ? Generator->GetOption(op) : CM_NULLPTR; + return option && *option ? option : CM_NULLPTR; } bool cmCPackIFWPackage::IsOn(const std::string& op) const diff --git a/Source/CPack/IFW/cmCPackIFWRepository.cxx b/Source/CPack/IFW/cmCPackIFWRepository.cxx index b8a10c6..fcb1c77 100644 --- a/Source/CPack/IFW/cmCPackIFWRepository.cxx +++ b/Source/CPack/IFW/cmCPackIFWRepository.cxx @@ -35,7 +35,7 @@ cmCPackIFWRepository::cmCPackIFWRepository() : Update(None) - , Generator(0) + , Generator(CM_NULLPTR) { } @@ -63,7 +63,7 @@ bool cmCPackIFWRepository::IsValid() const const char* cmCPackIFWRepository::GetOption(const std::string& op) const { - return Generator ? Generator->GetOption(op) : 0; + return Generator ? Generator->GetOption(op) : CM_NULLPTR; } bool cmCPackIFWRepository::IsOn(const std::string& op) const @@ -177,7 +177,7 @@ public: bool patched; protected: - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { xout.StartElement(name); StartFragment(atts); @@ -192,7 +192,7 @@ protected: } } - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "Updates" && !patched) { repository->WriteRepositoryUpdates(xout); @@ -208,7 +208,7 @@ protected: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { std::string content(data, data + length); if (content == "" || content == " " || content == " " || @@ -299,8 +299,8 @@ void cmCPackIFWRepository::WriteRepositoryUpdate(cmXMLWriter& xout) if (Update == Add || Update == Remove) { xout.Attribute("url", Url); } else if (Update == Replace) { - xout.Attribute("oldurl", OldUrl); - xout.Attribute("newurl", NewUrl); + xout.Attribute("oldUrl", OldUrl); + xout.Attribute("newUrl", NewUrl); } // Enabled if (!Enabled.empty()) { diff --git a/Source/CPack/WiX/cmCPackWIXGenerator.cxx b/Source/CPack/WiX/cmCPackWIXGenerator.cxx index b5b364d..97216c3 100644 --- a/Source/CPack/WiX/cmCPackWIXGenerator.cxx +++ b/Source/CPack/WiX/cmCPackWIXGenerator.cxx @@ -1044,7 +1044,7 @@ std::string cmCPackWIXGenerator::CreateNewIdForPath(std::string const& path) std::string cmCPackWIXGenerator::CreateHashedId( std::string const& path, std::string const& normalizedFilename) { - cmsys::auto_ptr<cmCryptoHash> sha1 = cmCryptoHash::New("SHA1"); + CM_AUTO_PTR<cmCryptoHash> sha1 = cmCryptoHash::New("SHA1"); std::string hash = sha1->HashString(path.c_str()); std::string identifier; diff --git a/Source/CPack/cmCPack7zGenerator.h b/Source/CPack/cmCPack7zGenerator.h index f5a323f..ddbcc34 100644 --- a/Source/CPack/cmCPack7zGenerator.h +++ b/Source/CPack/cmCPack7zGenerator.h @@ -27,10 +27,10 @@ public: * Construct generator */ cmCPack7zGenerator(); - virtual ~cmCPack7zGenerator(); + ~cmCPack7zGenerator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".7z"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".7z"; } }; #endif diff --git a/Source/CPack/cmCPackArchiveGenerator.cxx b/Source/CPack/cmCPackArchiveGenerator.cxx index baf6719..b1f6864 100644 --- a/Source/CPack/cmCPackArchiveGenerator.cxx +++ b/Source/CPack/cmCPackArchiveGenerator.cxx @@ -68,7 +68,7 @@ int cmCPackArchiveGenerator::addOneComponentToArchive( ++fileIt) { std::string rp = filePrefix + *fileIt; cmCPackLogger(cmCPackLog::LOG_DEBUG, "Adding file: " << rp << std::endl); - archive.Add(rp, 0, 0, false); + archive.Add(rp, 0, CM_NULLPTR, false); if (!archive) { cmCPackLogger(cmCPackLog::LOG_ERROR, "ERROR while packaging files: " << archive.GetError() << std::endl); @@ -139,7 +139,7 @@ int cmCPackArchiveGenerator::PackageComponents(bool ignoreGroup) for (compIt = this->Components.begin(); compIt != this->Components.end(); ++compIt) { // Does the component belong to a group? - if (compIt->second.Group == NULL) { + if (compIt->second.Group == CM_NULLPTR) { cmCPackLogger( cmCPackLog::LOG_VERBOSE, "Component <" << compIt->second.Name @@ -246,7 +246,7 @@ int cmCPackArchiveGenerator::PackageFiles() // Get the relative path to the file std::string rp = cmSystemTools::RelativePath(toplevel.c_str(), fileIt->c_str()); - archive.Add(rp, 0, 0, false); + archive.Add(rp, 0, CM_NULLPTR, false); if (!archive) { cmCPackLogger(cmCPackLog::LOG_ERROR, "Problem while adding file< " << *fileIt << "> to archive <" << packageFileNames[0] diff --git a/Source/CPack/cmCPackArchiveGenerator.h b/Source/CPack/cmCPackArchiveGenerator.h index 9eb38b1..a018ebd 100644 --- a/Source/CPack/cmCPackArchiveGenerator.h +++ b/Source/CPack/cmCPackArchiveGenerator.h @@ -32,14 +32,14 @@ public: * Construct generator */ cmCPackArchiveGenerator(cmArchiveWrite::Compress, std::string const& format); - virtual ~cmCPackArchiveGenerator(); + ~cmCPackArchiveGenerator() CM_OVERRIDE; // Used to add a header to the archive virtual int GenerateHeader(std::ostream* os); // component support - virtual bool SupportsComponentInstallation() const; + bool SupportsComponentInstallation() const CM_OVERRIDE; protected: - virtual int InitializeInternal(); + int InitializeInternal() CM_OVERRIDE; /** * Add the files belonging to the specified component * to the provided (already opened) archive. @@ -55,7 +55,7 @@ protected: * method will call either PackageComponents or * PackageComponentsAllInOne. */ - int PackageFiles(); + int PackageFiles() CM_OVERRIDE; /** * The method used to package files when component * install is used. This will create one @@ -67,7 +67,7 @@ protected: * components will be put in a single installer. */ int PackageComponentsAllInOne(); - virtual const char* GetOutputExtension() = 0; + const char* GetOutputExtension() CM_OVERRIDE = 0; cmArchiveWrite::Compress Compress; std::string ArchiveFormat; }; diff --git a/Source/CPack/cmCPackComponentGroup.h b/Source/CPack/cmCPackComponentGroup.h index 5361d95..01a9e76 100644 --- a/Source/CPack/cmCPackComponentGroup.h +++ b/Source/CPack/cmCPackComponentGroup.h @@ -43,7 +43,7 @@ class cmCPackComponent { public: cmCPackComponent() - : Group(0) + : Group(CM_NULLPTR) , IsRequired(true) , IsHidden(false) , IsDisabledByDefault(false) @@ -117,7 +117,7 @@ class cmCPackComponentGroup { public: cmCPackComponentGroup() - : ParentGroup(0) + : ParentGroup(CM_NULLPTR) { } diff --git a/Source/CPack/cmCPackDebGenerator.cxx b/Source/CPack/cmCPackDebGenerator.cxx index b659359..3edc430 100644 --- a/Source/CPack/cmCPackDebGenerator.cxx +++ b/Source/CPack/cmCPackDebGenerator.cxx @@ -133,7 +133,7 @@ int cmCPackDebGenerator::PackageComponents(bool ignoreGroup) for (compIt = this->Components.begin(); compIt != this->Components.end(); ++compIt) { // Does the component belong to a group? - if (compIt->second.Group == NULL) { + if (compIt->second.Group == CM_NULLPTR) { cmCPackLogger( cmCPackLog::LOG_VERBOSE, "Component <" << compIt->second.Name @@ -692,7 +692,7 @@ std::string cmCPackDebGenerator::GetComponentInstallDirNameSuffix( // the current COMPONENT belongs to. std::string groupVar = "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP"; - if (NULL != GetOption(groupVar)) { + if (CM_NULLPTR != GetOption(groupVar)) { return std::string(GetOption(groupVar)); } else { return componentName; @@ -917,18 +917,18 @@ static int ar_append(const char* archive, { int eval = 0; FILE* aFile = cmSystemTools::Fopen(archive, "wb+"); - if (aFile != NULL) { + if (aFile != CM_NULLPTR) { fwrite(ARMAG, SARMAG, 1, aFile); if (fseek(aFile, 0, SEEK_END) != -1) { CF cf; struct stat sb; /* Read from disk, write to an archive; pad on write. */ - SETCF(NULL, 0, aFile, archive, WPAD); + SETCF(CM_NULLPTR, CM_NULLPTR, aFile, archive, WPAD); for (std::vector<std::string>::const_iterator fileIt = files.begin(); fileIt != files.end(); ++fileIt) { const char* filename = fileIt->c_str(); FILE* file = cmSystemTools::Fopen(filename, "rb"); - if (file == NULL) { + if (file == CM_NULLPTR) { eval = -1; continue; } diff --git a/Source/CPack/cmCPackDebGenerator.h b/Source/CPack/cmCPackDebGenerator.h index ff34ca5..bcdc509 100644 --- a/Source/CPack/cmCPackDebGenerator.h +++ b/Source/CPack/cmCPackDebGenerator.h @@ -28,7 +28,7 @@ public: * Construct generator */ cmCPackDebGenerator(); - virtual ~cmCPackDebGenerator(); + ~cmCPackDebGenerator() CM_OVERRIDE; static bool CanGenerate() { @@ -45,7 +45,7 @@ public: } protected: - virtual int InitializeInternal(); + int InitializeInternal() CM_OVERRIDE; /** * This method factors out the work done in component packaging case. */ @@ -62,11 +62,11 @@ protected: * components will be put in a single installer. */ int PackageComponentsAllInOne(const std::string& compInstDirName); - virtual int PackageFiles(); - virtual const char* GetOutputExtension() { return ".deb"; } - virtual bool SupportsComponentInstallation() const; - virtual std::string GetComponentInstallDirNameSuffix( - const std::string& componentName); + int PackageFiles() CM_OVERRIDE; + const char* GetOutputExtension() CM_OVERRIDE { return ".deb"; } + bool SupportsComponentInstallation() const CM_OVERRIDE; + std::string GetComponentInstallDirNameSuffix( + const std::string& componentName) CM_OVERRIDE; private: int createDeb(); diff --git a/Source/CPack/cmCPackGenerator.cxx b/Source/CPack/cmCPackGenerator.cxx index c8b075d..df8bb0f 100644 --- a/Source/CPack/cmCPackGenerator.cxx +++ b/Source/CPack/cmCPackGenerator.cxx @@ -34,14 +34,14 @@ cmCPackGenerator::cmCPackGenerator() { this->GeneratorVerbose = cmSystemTools::OUTPUT_NONE; - this->MakefileMap = 0; - this->Logger = 0; + this->MakefileMap = CM_NULLPTR; + this->Logger = CM_NULLPTR; this->componentPackageMethod = ONE_PACKAGE_PER_GROUP; } cmCPackGenerator::~cmCPackGenerator() { - this->MakefileMap = 0; + this->MakefileMap = CM_NULLPTR; } void cmCPackGeneratorProgress(const char* msg, float prog, void* ptr) @@ -251,8 +251,9 @@ int cmCPackGenerator::InstallProjectViaInstallCommands( cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << *it << std::endl); std::string output; int retVal = 1; - bool resB = cmSystemTools::RunSingleCommand( - it->c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0); + bool resB = + cmSystemTools::RunSingleCommand(it->c_str(), &output, &output, &retVal, + CM_NULLPTR, this->GeneratorVerbose, 0); if (!resB || retVal) { std::string tmpFile = this->GetOption("CPACK_TOPLEVEL_DIRECTORY"); tmpFile += "/InstallOutput.log"; @@ -623,7 +624,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( cm.AddCMakePaths(); cm.SetProgressCallback(cmCPackGeneratorProgress, this); cmGlobalGenerator gg(&cm); - cmsys::auto_ptr<cmMakefile> mf( + CM_AUTO_PTR<cmMakefile> mf( new cmMakefile(&gg, cm.GetCurrentSnapshot())); if (!installSubDirectory.empty() && installSubDirectory != "/") { tempInstallDirectory += installSubDirectory; @@ -814,7 +815,8 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( } } - if (NULL != mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) { + if (CM_NULLPTR != + mf->GetDefinition("CPACK_ABSOLUTE_DESTINATION_FILES")) { if (!absoluteDestFiles.empty()) { absoluteDestFiles += ";"; } @@ -828,7 +830,7 @@ int cmCPackGenerator::InstallProjectViaInstallCMakeProjects( std::string absoluteDestFileComponent = std::string("CPACK_ABSOLUTE_DESTINATION_FILES") + "_" + GetComponentInstallDirNameSuffix(installComponent); - if (NULL != this->GetOption(absoluteDestFileComponent)) { + if (CM_NULLPTR != this->GetOption(absoluteDestFileComponent)) { std::string absoluteDestFilesListComponent = this->GetOption(absoluteDestFileComponent); absoluteDestFilesListComponent += ";"; @@ -1178,7 +1180,7 @@ int cmCPackGenerator::PrepareGroupingKind() std::string groupingType; // Second way to specify grouping - if (NULL != this->GetOption("CPACK_COMPONENTS_GROUPING")) { + if (CM_NULLPTR != this->GetOption("CPACK_COMPONENTS_GROUPING")) { groupingType = this->GetOption("CPACK_COMPONENTS_GROUPING"); } @@ -1355,7 +1357,7 @@ cmCPackComponent* cmCPackGenerator::GetComponent( component->Group = GetComponentGroup(projectName, groupName); component->Group->Components.push_back(component); } else { - component->Group = 0; + component->Group = CM_NULLPTR; } const char* description = this->GetOption(macroPrefix + "_DESCRIPTION"); @@ -1423,7 +1425,7 @@ cmCPackComponentGroup* cmCPackGenerator::GetComponentGroup( group->ParentGroup = GetComponentGroup(projectName, parentGroupName); group->ParentGroup->Subgroups.push_back(group); } else { - group->ParentGroup = 0; + group->ParentGroup = CM_NULLPTR; } } return group; diff --git a/Source/CPack/cmCPackGenerator.h b/Source/CPack/cmCPackGenerator.h index ce93715..23e4bb7 100644 --- a/Source/CPack/cmCPackGenerator.h +++ b/Source/CPack/cmCPackGenerator.h @@ -101,7 +101,7 @@ public: * Construct generator */ cmCPackGenerator(); - virtual ~cmCPackGenerator(); + ~cmCPackGenerator() CM_OVERRIDE; //! Set and get the options void SetOption(const std::string& op, const char* value); @@ -136,7 +136,7 @@ protected: cmInstalledFile const* GetInstalledFile(std::string const& name) const; virtual const char* GetOutputExtension() { return ".cpack"; } - virtual const char* GetOutputPostfix() { return 0; } + virtual const char* GetOutputPostfix() { return CM_NULLPTR; } /** * Prepare requested grouping kind from CPACK_xxx vars diff --git a/Source/CPack/cmCPackGeneratorFactory.cxx b/Source/CPack/cmCPackGeneratorFactory.cxx index 2210835..0f0268f 100644 --- a/Source/CPack/cmCPackGeneratorFactory.cxx +++ b/Source/CPack/cmCPackGeneratorFactory.cxx @@ -151,7 +151,7 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGenerator( { cmCPackGenerator* gen = this->NewGeneratorInternal(name); if (!gen) { - return 0; + return CM_NULLPTR; } this->Generators.push_back(gen); gen->SetLogger(this->Logger); @@ -164,7 +164,7 @@ cmCPackGenerator* cmCPackGeneratorFactory::NewGeneratorInternal( cmCPackGeneratorFactory::t_GeneratorCreatorsMap::iterator it = this->GeneratorCreators.find(name); if (it == this->GeneratorCreators.end()) { - return 0; + return CM_NULLPTR; } return (it->second)(); } diff --git a/Source/CPack/cmCPackGeneratorFactory.h b/Source/CPack/cmCPackGeneratorFactory.h index a55ec6e..f0ed57a 100644 --- a/Source/CPack/cmCPackGeneratorFactory.h +++ b/Source/CPack/cmCPackGeneratorFactory.h @@ -28,7 +28,7 @@ public: cmTypeMacro(cmCPackGeneratorFactory, cmObject); cmCPackGeneratorFactory(); - ~cmCPackGeneratorFactory(); + ~cmCPackGeneratorFactory() CM_OVERRIDE; //! Get the generator cmCPackGenerator* NewGenerator(const std::string& name); diff --git a/Source/CPack/cmCPackLog.cxx b/Source/CPack/cmCPackLog.cxx index ff06eb8..339323e 100644 --- a/Source/CPack/cmCPackLog.cxx +++ b/Source/CPack/cmCPackLog.cxx @@ -28,13 +28,13 @@ cmCPackLog::cmCPackLog() this->DefaultOutput = &std::cout; this->DefaultError = &std::cerr; - this->LogOutput = 0; + this->LogOutput = CM_NULLPTR; this->LogOutputCleanup = false; } cmCPackLog::~cmCPackLog() { - this->SetLogOutputStream(0); + this->SetLogOutputStream(CM_NULLPTR); } void cmCPackLog::SetLogOutputStream(std::ostream* os) @@ -48,13 +48,13 @@ void cmCPackLog::SetLogOutputStream(std::ostream* os) bool cmCPackLog::SetLogOutputFile(const char* fname) { - cmGeneratedFileStream* cg = 0; + cmGeneratedFileStream* cg = CM_NULLPTR; if (fname) { cg = new cmGeneratedFileStream(fname); } if (cg && !*cg) { delete cg; - cg = 0; + cg = CM_NULLPTR; } this->SetLogOutputStream(cg); if (!cg) { diff --git a/Source/CPack/cmCPackLog.h b/Source/CPack/cmCPackLog.h index 41871cc..77f0f0b 100644 --- a/Source/CPack/cmCPackLog.h +++ b/Source/CPack/cmCPackLog.h @@ -42,7 +42,7 @@ public: cmTypeMacro(cmCPackLog, cmObject); cmCPackLog(); - ~cmCPackLog(); + ~cmCPackLog() CM_OVERRIDE; enum __log_tags { diff --git a/Source/CPack/cmCPackNSISGenerator.cxx b/Source/CPack/cmCPackNSISGenerator.cxx index 5123edd..d8ff907 100644 --- a/Source/CPack/cmCPackNSISGenerator.cxx +++ b/Source/CPack/cmCPackNSISGenerator.cxx @@ -212,7 +212,7 @@ int cmCPackNSISGenerator::PackageFiles() std::map<std::string, cmCPackComponentGroup>::iterator groupIt; for (groupIt = this->ComponentGroups.begin(); groupIt != this->ComponentGroups.end(); ++groupIt) { - if (groupIt->second.ParentGroup == 0) { + if (groupIt->second.ParentGroup == CM_NULLPTR) { componentCode += this->CreateComponentGroupDescription(&groupIt->second, macrosOut); } @@ -301,8 +301,9 @@ int cmCPackNSISGenerator::PackageFiles() cmCPackLogger(cmCPackLog::LOG_VERBOSE, "Execute: " << nsisCmd << std::endl); std::string output; int retVal = 1; - bool res = cmSystemTools::RunSingleCommand( - nsisCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0); + bool res = + cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output, &output, &retVal, + CM_NULLPTR, this->GeneratorVerbose, 0); if (!res || retVal) { cmGeneratedFileStream ofs(tmpFile.c_str()); ofs << "# Run command: " << nsisCmd << std::endl @@ -326,7 +327,7 @@ int cmCPackNSISGenerator::InitializeInternal() "NSIS Generator cannot work with CPACK_INCLUDE_TOPLEVEL_DIRECTORY set. " "This option will be reset to 0 (for this generator only)." << std::endl); - this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", 0); + this->SetOption("CPACK_INCLUDE_TOPLEVEL_DIRECTORY", CM_NULLPTR); } cmCPackLogger(cmCPackLog::LOG_DEBUG, "cmCPackNSISGenerator::Initialize()" @@ -399,8 +400,9 @@ int cmCPackNSISGenerator::InitializeInternal() << std::endl); std::string output; int retVal = 1; - bool resS = cmSystemTools::RunSingleCommand( - nsisCmd.c_str(), &output, &output, &retVal, 0, this->GeneratorVerbose, 0); + bool resS = + cmSystemTools::RunSingleCommand(nsisCmd.c_str(), &output, &output, &retVal, + CM_NULLPTR, this->GeneratorVerbose, 0); cmsys::RegularExpression versionRex("v([0-9]+.[0-9]+)"); cmsys::RegularExpression versionRexCVS("v(.*)\\.cvs"); if (!resS || retVal || diff --git a/Source/CPack/cmCPackNSISGenerator.h b/Source/CPack/cmCPackNSISGenerator.h index ae3ccca..4923cf0 100644 --- a/Source/CPack/cmCPackNSISGenerator.h +++ b/Source/CPack/cmCPackNSISGenerator.h @@ -36,21 +36,22 @@ public: * Construct generator */ cmCPackNSISGenerator(bool nsis64 = false); - virtual ~cmCPackNSISGenerator(); + ~cmCPackNSISGenerator() CM_OVERRIDE; protected: - virtual int InitializeInternal(); + int InitializeInternal() CM_OVERRIDE; void CreateMenuLinks(std::ostream& str, std::ostream& deleteStr); - int PackageFiles(); - virtual const char* GetOutputExtension() { return ".exe"; } - virtual const char* GetOutputPostfix() { return "win32"; } + int PackageFiles() CM_OVERRIDE; + const char* GetOutputExtension() CM_OVERRIDE { return ".exe"; } + const char* GetOutputPostfix() CM_OVERRIDE { return "win32"; } bool GetListOfSubdirectories(const char* dir, std::vector<std::string>& dirs); - enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const; - virtual bool SupportsAbsoluteDestination() const; - virtual bool SupportsComponentInstallation() const; + enum cmCPackGenerator::CPackSetDestdirSupport SupportsSetDestdir() const + CM_OVERRIDE; + bool SupportsAbsoluteDestination() const CM_OVERRIDE; + bool SupportsComponentInstallation() const CM_OVERRIDE; /// Produce a string that contains the NSIS code to describe a /// particular component. Any added macros will be emitted via diff --git a/Source/CPack/cmCPackRPMGenerator.cxx b/Source/CPack/cmCPackRPMGenerator.cxx index bc10111..2568d17 100644 --- a/Source/CPack/cmCPackRPMGenerator.cxx +++ b/Source/CPack/cmCPackRPMGenerator.cxx @@ -121,7 +121,7 @@ int cmCPackRPMGenerator::PackageComponents(bool ignoreGroup) for (compIt = this->Components.begin(); compIt != this->Components.end(); ++compIt) { // Does the component belong to a group? - if (compIt->second.Group == NULL) { + if (compIt->second.Group == CM_NULLPTR) { cmCPackLogger( cmCPackLog::LOG_VERBOSE, "Component <" << compIt->second.Name @@ -245,7 +245,7 @@ std::string cmCPackRPMGenerator::GetComponentInstallDirNameSuffix( // the current COMPONENT belongs to. std::string groupVar = "CPACK_COMPONENT_" + cmSystemTools::UpperCase(componentName) + "_GROUP"; - if (NULL != GetOption(groupVar)) { + if (CM_NULLPTR != GetOption(groupVar)) { return std::string(GetOption(groupVar)); } else { return componentName; diff --git a/Source/CPack/cmCPackRPMGenerator.h b/Source/CPack/cmCPackRPMGenerator.h index b39f2c2..4baef08 100644 --- a/Source/CPack/cmCPackRPMGenerator.h +++ b/Source/CPack/cmCPackRPMGenerator.h @@ -32,7 +32,7 @@ public: * Construct generator */ cmCPackRPMGenerator(); - virtual ~cmCPackRPMGenerator(); + ~cmCPackRPMGenerator() CM_OVERRIDE; static bool CanGenerate() { @@ -49,8 +49,8 @@ public: } protected: - virtual int InitializeInternal(); - virtual int PackageFiles(); + int InitializeInternal() CM_OVERRIDE; + int PackageFiles() CM_OVERRIDE; /** * This method factors out the work done in component packaging case. */ @@ -67,10 +67,10 @@ protected: * components will be put in a single installer. */ int PackageComponentsAllInOne(const std::string& compInstDirName); - virtual const char* GetOutputExtension() { return ".rpm"; } - virtual bool SupportsComponentInstallation() const; - virtual std::string GetComponentInstallDirNameSuffix( - const std::string& componentName); + const char* GetOutputExtension() CM_OVERRIDE { return ".rpm"; } + bool SupportsComponentInstallation() const CM_OVERRIDE; + std::string GetComponentInstallDirNameSuffix( + const std::string& componentName) CM_OVERRIDE; void AddGeneratedPackageNames(); }; diff --git a/Source/CPack/cmCPackSTGZGenerator.h b/Source/CPack/cmCPackSTGZGenerator.h index 08152b5..94cc8aa 100644 --- a/Source/CPack/cmCPackSTGZGenerator.h +++ b/Source/CPack/cmCPackSTGZGenerator.h @@ -28,13 +28,13 @@ public: * Construct generator */ cmCPackSTGZGenerator(); - virtual ~cmCPackSTGZGenerator(); + ~cmCPackSTGZGenerator() CM_OVERRIDE; protected: - int PackageFiles(); - virtual int InitializeInternal(); - int GenerateHeader(std::ostream* os); - virtual const char* GetOutputExtension() { return ".sh"; } + int PackageFiles() CM_OVERRIDE; + int InitializeInternal() CM_OVERRIDE; + int GenerateHeader(std::ostream* os) CM_OVERRIDE; + const char* GetOutputExtension() CM_OVERRIDE { return ".sh"; } }; #endif diff --git a/Source/CPack/cmCPackTGZGenerator.h b/Source/CPack/cmCPackTGZGenerator.h index 408422b..cb7620c 100644 --- a/Source/CPack/cmCPackTGZGenerator.h +++ b/Source/CPack/cmCPackTGZGenerator.h @@ -27,10 +27,10 @@ public: * Construct generator */ cmCPackTGZGenerator(); - virtual ~cmCPackTGZGenerator(); + ~cmCPackTGZGenerator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".tar.gz"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".tar.gz"; } }; #endif diff --git a/Source/CPack/cmCPackTXZGenerator.h b/Source/CPack/cmCPackTXZGenerator.h index 05052a1..87c92ef 100644 --- a/Source/CPack/cmCPackTXZGenerator.h +++ b/Source/CPack/cmCPackTXZGenerator.h @@ -27,10 +27,10 @@ public: * Construct generator */ cmCPackTXZGenerator(); - virtual ~cmCPackTXZGenerator(); + ~cmCPackTXZGenerator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".tar.xz"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".tar.xz"; } }; #endif diff --git a/Source/CPack/cmCPackTarBZip2Generator.h b/Source/CPack/cmCPackTarBZip2Generator.h index 4033197..6fec882 100644 --- a/Source/CPack/cmCPackTarBZip2Generator.h +++ b/Source/CPack/cmCPackTarBZip2Generator.h @@ -26,10 +26,10 @@ public: * Construct generator */ cmCPackTarBZip2Generator(); - virtual ~cmCPackTarBZip2Generator(); + ~cmCPackTarBZip2Generator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".tar.bz2"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".tar.bz2"; } }; #endif diff --git a/Source/CPack/cmCPackTarCompressGenerator.h b/Source/CPack/cmCPackTarCompressGenerator.h index 7ff9a0a..02926a2 100644 --- a/Source/CPack/cmCPackTarCompressGenerator.h +++ b/Source/CPack/cmCPackTarCompressGenerator.h @@ -26,10 +26,10 @@ public: * Construct generator */ cmCPackTarCompressGenerator(); - virtual ~cmCPackTarCompressGenerator(); + ~cmCPackTarCompressGenerator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".tar.Z"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".tar.Z"; } }; #endif diff --git a/Source/CPack/cmCPackZIPGenerator.h b/Source/CPack/cmCPackZIPGenerator.h index 70e1a5f..1130826 100644 --- a/Source/CPack/cmCPackZIPGenerator.h +++ b/Source/CPack/cmCPackZIPGenerator.h @@ -27,10 +27,10 @@ public: * Construct generator */ cmCPackZIPGenerator(); - virtual ~cmCPackZIPGenerator(); + ~cmCPackZIPGenerator() CM_OVERRIDE; protected: - virtual const char* GetOutputExtension() { return ".zip"; } + const char* GetOutputExtension() CM_OVERRIDE { return ".zip"; } }; #endif diff --git a/Source/CPack/cpack.cxx b/Source/CPack/cpack.cxx index 425afd9..771519c 100644 --- a/Source/CPack/cpack.cxx +++ b/Source/CPack/cpack.cxx @@ -27,13 +27,13 @@ #include <cmsys/SystemTools.hxx> static const char* cmDocumentationName[][2] = { - { 0, " cpack - Packaging driver provided by CMake." }, - { 0, 0 } + { CM_NULLPTR, " cpack - Packaging driver provided by CMake." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationUsage[][2] = { - { 0, " cpack -G <generator> [options]" }, - { 0, 0 } + { CM_NULLPTR, " cpack -G <generator> [options]" }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationOptions[][2] = { @@ -47,7 +47,7 @@ static const char* cmDocumentationOptions[][2] = { { "-R <package version>", "override/define CPACK_PACKAGE_VERSION" }, { "-B <package directory>", "override/define CPACK_PACKAGE_DIRECTORY" }, { "--vendor <vendor name>", "override/define CPACK_PACKAGE_VENDOR" }, - { 0, 0 } + { CM_NULLPTR, CM_NULLPTR } }; int cpackUnknownArgument(const char*, void*) @@ -185,7 +185,7 @@ int main(int argc, char const* const* argv) cminst.GetCurrentSnapshot().SetDefaultDefinitions(); cminst.GetState()->RemoveUnscriptableCommands(); cmGlobalGenerator cmgg(&cminst); - cmsys::auto_ptr<cmMakefile> globalMF( + CM_AUTO_PTR<cmMakefile> globalMF( new cmMakefile(&cmgg, cminst.GetCurrentSnapshot())); #if defined(__CYGWIN__) globalMF->AddDefinition("CMAKE_LEGACY_CYGWIN_WIN32", "0"); @@ -200,7 +200,7 @@ int main(int argc, char const* const* argv) cmCPackGeneratorFactory generators; generators.SetLogger(&log); - cmCPackGenerator* cpackGenerator = 0; + cmCPackGenerator* cpackGenerator = CM_NULLPTR; cmDocumentation doc; doc.addCPackStandardDocSections(); diff --git a/Source/CTest/cmCTestBZR.cxx b/Source/CTest/cmCTestBZR.cxx index 92eb570..0e08e1c 100644 --- a/Source/CTest/cmCTestBZR.cxx +++ b/Source/CTest/cmCTestBZR.cxx @@ -101,7 +101,7 @@ private: bool CheckOutFound; cmsys::RegularExpression RegexCheckOut; cmsys::RegularExpression RegexParent; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexCheckOut.find(this->Line)) { this->BZR->URL = this->RegexCheckOut.match(1); @@ -126,7 +126,7 @@ public: private: std::string& Rev; cmsys::RegularExpression RegexRevno; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexRevno.find(this->Line)) { this->Rev = this->RegexRevno.match(1); @@ -139,13 +139,13 @@ std::string cmCTestBZR::LoadInfo() { // Run "bzr info" to get the repository info from the work tree. const char* bzr = this->CommandLineTool.c_str(); - const char* bzr_info[] = { bzr, "info", 0 }; + const char* bzr_info[] = { bzr, "info", CM_NULLPTR }; InfoParser iout(this, "info-out> "); OutputLogger ierr(this->Log, "info-err> "); this->RunChild(bzr_info, &iout, &ierr); // Run "bzr revno" to get the repository revision number from the work tree. - const char* bzr_revno[] = { bzr, "revno", 0 }; + const char* bzr_revno[] = { bzr, "revno", CM_NULLPTR }; std::string rev; RevnoParser rout(this, "revno-out> ", rev); OutputLogger rerr(this->Log, "revno-err> "); @@ -183,14 +183,15 @@ public: { this->InitializeParser(); } - ~LogParser() { this->CleanupParser(); } + ~LogParser() CM_OVERRIDE { this->CleanupParser(); } - virtual int InitializeParser() + int InitializeParser() CM_OVERRIDE { int res = cmXMLParser::InitializeParser(); if (res) { XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser), - cmBZRXMLParserUnknownEncodingHandler, 0); + cmBZRXMLParserUnknownEncodingHandler, + CM_NULLPTR); } return res; } @@ -207,14 +208,14 @@ private: cmsys::RegularExpression EmailRegex; - virtual bool ProcessChunk(const char* data, int length) + bool ProcessChunk(const char* data, int length) CM_OVERRIDE { this->OutputLogger::ProcessChunk(data, length); this->ParseChunk(data, length); return true; } - virtual void StartElement(const std::string& name, const char**) + void StartElement(const std::string& name, const char**) CM_OVERRIDE { this->CData.clear(); if (name == "log") { @@ -239,12 +240,12 @@ private: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { this->CData.insert(this->CData.end(), data, data + length); } - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "log") { this->BZR->DoRevision(this->Rev, this->Changes); @@ -274,7 +275,7 @@ private: this->CData.clear(); } - virtual void ReportError(int, int, const char* msg) + void ReportError(int, int, const char* msg) CM_OVERRIDE { this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n"; } @@ -294,7 +295,7 @@ private: cmCTestBZR* BZR; cmsys::RegularExpression RegexUpdate; - virtual bool ProcessChunk(const char* first, int length) + bool ProcessChunk(const char* first, int length) CM_OVERRIDE { bool last_is_new_line = (*first == '\r' || *first == '\n'); @@ -325,7 +326,7 @@ private: return true; } - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexUpdate.find(this->Line)) { this->DoPath(this->RegexUpdate.match(1)[0], @@ -380,7 +381,7 @@ bool cmCTestBZR::UpdateImpl() bzr_update.push_back(this->URL.c_str()); - bzr_update.push_back(0); + bzr_update.push_back(CM_NULLPTR); // For some reason bzr uses stderr to display the update status. OutputLogger out(this->Log, "pull-out> "); @@ -408,7 +409,8 @@ void cmCTestBZR::LoadRevisions() // Run "bzr log" to get all global revisions of interest. const char* bzr = this->CommandLineTool.c_str(); const char* bzr_log[] = { - bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), 0 + bzr, "log", "-v", "-r", revs.c_str(), "--xml", this->URL.c_str(), + CM_NULLPTR }; { LogParser out(this, "log-out> "); @@ -431,7 +433,7 @@ public: private: cmCTestBZR* BZR; cmsys::RegularExpression RegexStatus; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexStatus.find(this->Line)) { this->DoPath(this->RegexStatus.match(1)[0], @@ -465,7 +467,7 @@ void cmCTestBZR::LoadModifications() { // Run "bzr status" which reports local modifications. const char* bzr = this->CommandLineTool.c_str(); - const char* bzr_status[] = { bzr, "status", "-SV", 0 }; + const char* bzr_status[] = { bzr, "status", "-SV", CM_NULLPTR }; StatusParser out(this, "status-out> "); OutputLogger err(this->Log, "status-err> "); this->RunChild(bzr_status, &out, &err); diff --git a/Source/CTest/cmCTestBZR.h b/Source/CTest/cmCTestBZR.h index 4f44136..0f05d38 100644 --- a/Source/CTest/cmCTestBZR.h +++ b/Source/CTest/cmCTestBZR.h @@ -24,20 +24,20 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestBZR(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestBZR(); + ~cmCTestBZR() CM_OVERRIDE; private: // Implement cmCTestVC internal API. - virtual void NoteOldRevision(); - virtual void NoteNewRevision(); - virtual bool UpdateImpl(); + void NoteOldRevision() CM_OVERRIDE; + void NoteNewRevision() CM_OVERRIDE; + bool UpdateImpl() CM_OVERRIDE; // URL of repository directory checked out in the working tree. std::string URL; std::string LoadInfo(); - void LoadModifications(); - void LoadRevisions(); + void LoadModifications() CM_OVERRIDE; + void LoadRevisions() CM_OVERRIDE; // Parsing helper classes. class InfoParser; diff --git a/Source/CTest/cmCTestBatchTestHandler.h b/Source/CTest/cmCTestBatchTestHandler.h index ed60ea3..17cc234 100644 --- a/Source/CTest/cmCTestBatchTestHandler.h +++ b/Source/CTest/cmCTestBatchTestHandler.h @@ -28,8 +28,8 @@ class cmCTestBatchTestHandler : public cmCTestMultiProcessHandler { public: - ~cmCTestBatchTestHandler(); - virtual void RunTests(); + ~cmCTestBatchTestHandler() CM_OVERRIDE; + void RunTests() CM_OVERRIDE; protected: void WriteBatchScript(); diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx index 632f452..eddbddc 100644 --- a/Source/CTest/cmCTestBuildAndTestHandler.cxx +++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx @@ -72,7 +72,7 @@ int cmCTestBuildAndTestHandler::RunCMake(std::string* outstring, args.push_back(toolset); } - const char* config = 0; + const char* config = CM_NULLPTR; if (!this->CTest->GetConfigType().empty()) { config = this->CTest->GetConfigType().c_str(); } @@ -158,10 +158,10 @@ public: } ~cmCTestBuildAndTestCaptureRAII() { - this->CM.SetProgressCallback(0, 0); - cmSystemTools::SetStderrCallback(0, 0); - cmSystemTools::SetStdoutCallback(0, 0); - cmSystemTools::SetMessageCallback(0, 0); + this->CM.SetProgressCallback(CM_NULLPTR, CM_NULLPTR); + cmSystemTools::SetStderrCallback(CM_NULLPTR, CM_NULLPTR); + cmSystemTools::SetStdoutCallback(CM_NULLPTR, CM_NULLPTR); + cmSystemTools::SetMessageCallback(CM_NULLPTR, CM_NULLPTR); } }; @@ -247,7 +247,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) } } std::string output; - const char* config = 0; + const char* config = CM_NULLPTR; if (!this->CTest->GetConfigType().empty()) { config = this->CTest->GetConfigType().c_str(); } @@ -321,7 +321,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) for (size_t k = 0; k < this->TestCommandArgs.size(); ++k) { testCommand.push_back(this->TestCommandArgs[k].c_str()); } - testCommand.push_back(0); + testCommand.push_back(CM_NULLPTR); std::string outs; int retval = 0; // run the test from the this->BuildRunDir if set @@ -347,8 +347,8 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring) } } - int runTestRes = - this->CTest->RunTest(testCommand, &outs, &retval, 0, remainingTime, 0); + int runTestRes = this->CTest->RunTest(testCommand, &outs, &retval, + CM_NULLPTR, remainingTime, CM_NULLPTR); if (runTestRes != cmsysProcess_State_Exited || retval != 0) { out << "Test command failed: " << testCommand[0] << "\n"; diff --git a/Source/CTest/cmCTestBuildAndTestHandler.h b/Source/CTest/cmCTestBuildAndTestHandler.h index d0443ae..2aa90a4 100644 --- a/Source/CTest/cmCTestBuildAndTestHandler.h +++ b/Source/CTest/cmCTestBuildAndTestHandler.h @@ -30,12 +30,12 @@ public: /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; //! Set all the build and test arguments - virtual int ProcessCommandLineArguments( - const std::string& currentArg, size_t& idx, - const std::vector<std::string>& allArgs); + int ProcessCommandLineArguments(const std::string& currentArg, size_t& idx, + const std::vector<std::string>& allArgs) + CM_OVERRIDE; /* * Get the output variable @@ -44,7 +44,7 @@ public: cmCTestBuildAndTestHandler(); - virtual void Initialize(); + void Initialize() CM_OVERRIDE; protected: ///! Run CMake and build a test and then run it as a single test. diff --git a/Source/CTest/cmCTestBuildCommand.cxx b/Source/CTest/cmCTestBuildCommand.cxx index 05cccbf..408a1a8 100644 --- a/Source/CTest/cmCTestBuildCommand.cxx +++ b/Source/CTest/cmCTestBuildCommand.cxx @@ -19,14 +19,14 @@ cmCTestBuildCommand::cmCTestBuildCommand() { - this->GlobalGenerator = 0; + this->GlobalGenerator = CM_NULLPTR; this->Arguments[ctb_NUMBER_ERRORS] = "NUMBER_ERRORS"; this->Arguments[ctb_NUMBER_WARNINGS] = "NUMBER_WARNINGS"; this->Arguments[ctb_TARGET] = "TARGET"; this->Arguments[ctb_CONFIGURATION] = "CONFIGURATION"; this->Arguments[ctb_FLAGS] = "FLAGS"; this->Arguments[ctb_PROJECT_NAME] = "PROJECT_NAME"; - this->Arguments[ctb_LAST] = 0; + this->Arguments[ctb_LAST] = CM_NULLPTR; this->Last = ctb_LAST; } @@ -34,7 +34,7 @@ cmCTestBuildCommand::~cmCTestBuildCommand() { if (this->GlobalGenerator) { delete this->GlobalGenerator; - this->GlobalGenerator = 0; + this->GlobalGenerator = CM_NULLPTR; } } @@ -43,7 +43,7 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler() cmCTestGenericHandler* handler = this->CTest->GetInitializedHandler("build"); if (!handler) { this->SetError("internal CTest error. Cannot instantiate build handler"); - return 0; + return CM_NULLPTR; } this->Handler = (cmCTestBuildHandler*)handler; @@ -91,7 +91,7 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler() if (this->GlobalGenerator) { if (this->GlobalGenerator->GetName() != cmakeGeneratorName) { delete this->GlobalGenerator; - this->GlobalGenerator = 0; + this->GlobalGenerator = CM_NULLPTR; } } if (!this->GlobalGenerator) { @@ -104,11 +104,11 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler() e += "\""; this->Makefile->IssueMessage(cmake::FATAL_ERROR, e); cmSystemTools::SetFatalErrorOccured(); - return 0; + return CM_NULLPTR; } } if (strlen(cmakeBuildConfiguration) == 0) { - const char* config = 0; + const char* config = CM_NULLPTR; #ifdef CMAKE_INTDIR config = CMAKE_INTDIR; #endif @@ -145,7 +145,7 @@ cmCTestGenericHandler* cmCTestBuildCommand::InitializeHandler() "with a custom command line."; /* clang-format on */ this->SetError(ostr.str()); - return 0; + return CM_NULLPTR; } } diff --git a/Source/CTest/cmCTestBuildCommand.h b/Source/CTest/cmCTestBuildCommand.h index f420c2f..92ae216 100644 --- a/Source/CTest/cmCTestBuildCommand.h +++ b/Source/CTest/cmCTestBuildCommand.h @@ -26,12 +26,12 @@ class cmCTestBuildCommand : public cmCTestHandlerCommand { public: cmCTestBuildCommand(); - ~cmCTestBuildCommand(); + ~cmCTestBuildCommand() CM_OVERRIDE; /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestBuildCommand* ni = new cmCTestBuildCommand; ni->CTest = this->CTest; @@ -42,10 +42,10 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_build"; } + std::string GetName() const CM_OVERRIDE { return "ctest_build"; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; cmTypeMacro(cmCTestBuildCommand, cmCTestHandlerCommand); @@ -65,7 +65,7 @@ protected: ctb_LAST }; - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; }; #endif diff --git a/Source/CTest/cmCTestBuildHandler.cxx b/Source/CTest/cmCTestBuildHandler.cxx index a4d9dee..f96ef6d 100644 --- a/Source/CTest/cmCTestBuildHandler.cxx +++ b/Source/CTest/cmCTestBuildHandler.cxx @@ -92,7 +92,7 @@ static const char* cmCTestErrorMatches[] = { "^The project cannot be built\\.", "^\\[ERROR\\]", "^Command .* failed with exit code", - 0 + CM_NULLPTR }; static const char* cmCTestErrorExceptions[] = { @@ -107,7 +107,7 @@ static const char* cmCTestErrorExceptions[] = { ":[ \\t]+Where:", "([^ :]+):([0-9]+): Warning", "------ Build started: .* ------", - 0 + CM_NULLPTR }; static const char* cmCTestWarningMatches[] = { @@ -132,7 +132,7 @@ static const char* cmCTestWarningMatches[] = { "cc-[0-9]* CC: REMARK File = .*, Line = [0-9]*", "^CMake Warning.*:", "^\\[WARNING\\]", - 0 + CM_NULLPTR }; static const char* cmCTestWarningExceptions[] = { @@ -152,7 +152,7 @@ static const char* cmCTestWarningExceptions[] = { "ld32: WARNING 85: definition of dataKey in", "cc: warning 422: Unknown option \"\\+b", "_with_warning_C", - 0 + CM_NULLPTR }; struct cmCTestBuildCompileErrorWarningRex @@ -170,7 +170,7 @@ static cmCTestBuildCompileErrorWarningRex cmCTestWarningErrorFileLine[] = { { "^([a-zA-Z./0-9_+ ~-]+)\\(([0-9]+)\\)", 1, 2 }, { "\"([a-zA-Z./0-9_+ ~-]+)\", line ([0-9]+)", 1, 2 }, { "File = ([a-zA-Z./0-9_+ ~-]+), Line = ([0-9]+)", 1, 2 }, - { 0, 0, 0 } + { CM_NULLPTR, 0, 0 } }; cmCTestBuildHandler::cmCTestBuildHandler() @@ -521,7 +521,7 @@ public: { } FragmentCompare() - : FTC(0) + : FTC(CM_NULLPTR) { } bool operator()(std::string const& l, std::string const& r) @@ -799,7 +799,7 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal, a != args.end(); ++a) { argv.push_back(a->c_str()); } - argv.push_back(0); + argv.push_back(CM_NULLPTR); cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command:", this->Quiet); @@ -851,7 +851,7 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal, // For every chunk of data int res; - while ((res = cmsysProcess_WaitForData(cp, &data, &length, 0))) { + while ((res = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR))) { // Replace '\0' with '\n', since '\0' does not really make sense. This is // for Visual Studio output for (int cc = 0; cc < length; ++cc) { @@ -870,8 +870,9 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal, } } - this->ProcessBuffer(0, 0, tick, tick_len, ofs, &this->BuildProcessingQueue); - this->ProcessBuffer(0, 0, tick, tick_len, ofs, + this->ProcessBuffer(CM_NULLPTR, 0, tick, tick_len, ofs, + &this->BuildProcessingQueue); + this->ProcessBuffer(CM_NULLPTR, 0, tick, tick_len, ofs, &this->BuildProcessingErrorQueue); cmCTestOptionalLog(this->CTest, HANDLER_PROGRESS_OUTPUT, " Size of output: " << ((this->BuildOutputLogSize + 512) / 1024) << "K" @@ -879,7 +880,7 @@ int cmCTestBuildHandler::RunMakeCommand(const char* command, int* retVal, this->Quiet); // Properly handle output of the build command - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); int result = cmsysProcess_GetState(cp); if (result == cmsysProcess_State_Exited) { diff --git a/Source/CTest/cmCTestBuildHandler.h b/Source/CTest/cmCTestBuildHandler.h index 48a37b7..8cc5f01 100644 --- a/Source/CTest/cmCTestBuildHandler.h +++ b/Source/CTest/cmCTestBuildHandler.h @@ -36,16 +36,16 @@ public: /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; cmCTestBuildHandler(); - void PopulateCustomVectors(cmMakefile* mf); + void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE; /** * Initialize handler */ - virtual void Initialize(); + void Initialize() CM_OVERRIDE; int GetTotalErrors() { return this->TotalErrors; } int GetTotalWarnings() { return this->TotalWarnings; } diff --git a/Source/CTest/cmCTestCVS.cxx b/Source/CTest/cmCTestCVS.cxx index 5ddafbb..37bdf9a 100644 --- a/Source/CTest/cmCTestCVS.cxx +++ b/Source/CTest/cmCTestCVS.cxx @@ -53,7 +53,7 @@ private: cmsys::RegularExpression RegexFileRemoved1; cmsys::RegularExpression RegexFileRemoved2; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexFileUpdated.find(this->Line)) { this->DoFile(PathUpdated, this->RegexFileUpdated.match(2)); @@ -103,7 +103,7 @@ bool cmCTestCVS::UpdateImpl() ai != args.end(); ++ai) { cvs_update.push_back(ai->c_str()); } - cvs_update.push_back(0); + cvs_update.push_back(CM_NULLPTR); UpdateParser out(this, "up-out> "); UpdateParser err(this, "up-err> "); @@ -140,7 +140,7 @@ private: SectionType Section; Revision Rev; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->Line == ("=======================================" "======================================")) { @@ -229,7 +229,8 @@ void cmCTestCVS::LoadRevisions(std::string const& file, const char* branchFlag, // Run "cvs log" to get revisions of this file on this branch. const char* cvs = this->CommandLineTool.c_str(); - const char* cvs_log[] = { cvs, "log", "-N", branchFlag, file.c_str(), 0 }; + const char* cvs_log[] = { cvs, "log", "-N", + branchFlag, file.c_str(), CM_NULLPTR }; LogParser out(this, "log-out> ", revisions); OutputLogger err(this->Log, "log-err> "); diff --git a/Source/CTest/cmCTestCVS.h b/Source/CTest/cmCTestCVS.h index 62fe01b..4d5e6a9 100644 --- a/Source/CTest/cmCTestCVS.h +++ b/Source/CTest/cmCTestCVS.h @@ -24,12 +24,12 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestCVS(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestCVS(); + ~cmCTestCVS() CM_OVERRIDE; private: // Implement cmCTestVC internal API. - virtual bool UpdateImpl(); - virtual bool WriteXMLUpdates(cmXMLWriter& xml); + bool UpdateImpl() CM_OVERRIDE; + bool WriteXMLUpdates(cmXMLWriter& xml) CM_OVERRIDE; // Update status for files in each directory. class Directory : public std::map<std::string, PathStatus> diff --git a/Source/CTest/cmCTestCommand.h b/Source/CTest/cmCTestCommand.h index 22a2c8e..b0c9206 100644 --- a/Source/CTest/cmCTestCommand.h +++ b/Source/CTest/cmCTestCommand.h @@ -29,8 +29,8 @@ class cmCTestCommand : public cmCommand public: cmCTestCommand() { - this->CTest = 0; - this->CTestScriptHandler = 0; + this->CTest = CM_NULLPTR; + this->CTestScriptHandler = CM_NULLPTR; } cmCTest* CTest; diff --git a/Source/CTest/cmCTestConfigureCommand.cxx b/Source/CTest/cmCTestConfigureCommand.cxx index a90f27a..a823704 100644 --- a/Source/CTest/cmCTestConfigureCommand.cxx +++ b/Source/CTest/cmCTestConfigureCommand.cxx @@ -18,7 +18,7 @@ cmCTestConfigureCommand::cmCTestConfigureCommand() { this->Arguments[ctc_OPTIONS] = "OPTIONS"; - this->Arguments[ctc_LAST] = 0; + this->Arguments[ctc_LAST] = CM_NULLPTR; this->Last = ctc_LAST; } @@ -35,7 +35,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() "Build directory not specified. Either use BUILD " "argument to CTEST_CONFIGURE command or set CTEST_BINARY_DIRECTORY " "variable"); - return 0; + return CM_NULLPTR; } const char* ctestConfigureCommand = @@ -55,7 +55,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() "Source directory not specified. Either use SOURCE " "argument to CTEST_CONFIGURE command or set CTEST_SOURCE_DIRECTORY " "variable"); - return 0; + return CM_NULLPTR; } const std::string cmakelists_file = source_dir + "/CMakeLists.txt"; @@ -63,7 +63,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() std::ostringstream e; e << "CMakeLists.txt file does not exist [" << cmakelists_file << "]"; this->SetError(e.str()); - return 0; + return CM_NULLPTR; } bool multiConfig = false; @@ -90,8 +90,9 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() cmakeConfigureCommand += option; cmakeConfigureCommand += "\""; - if ((0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE=")) || - (0 != strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING="))) { + if ((CM_NULLPTR != strstr(option.c_str(), "CMAKE_BUILD_TYPE=")) || + (CM_NULLPTR != + strstr(option.c_str(), "CMAKE_BUILD_TYPE:STRING="))) { cmakeBuildTypeInOptions = true; } } @@ -134,7 +135,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() "Configure command is not specified. If this is a " "\"built with CMake\" project, set CTEST_CMAKE_GENERATOR. If not, " "set CTEST_CONFIGURE_COMMAND."); - return 0; + return CM_NULLPTR; } } @@ -143,7 +144,7 @@ cmCTestGenericHandler* cmCTestConfigureCommand::InitializeHandler() if (!handler) { this->SetError( "internal CTest error. Cannot instantiate configure handler"); - return 0; + return CM_NULLPTR; } handler->SetQuiet(this->Quiet); return handler; diff --git a/Source/CTest/cmCTestConfigureCommand.h b/Source/CTest/cmCTestConfigureCommand.h index 9ff3d4a..a97f9f0 100644 --- a/Source/CTest/cmCTestConfigureCommand.h +++ b/Source/CTest/cmCTestConfigureCommand.h @@ -27,7 +27,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestConfigureCommand* ni = new cmCTestConfigureCommand; ni->CTest = this->CTest; @@ -38,12 +38,12 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_configure"; } + std::string GetName() const CM_OVERRIDE { return "ctest_configure"; } cmTypeMacro(cmCTestConfigureCommand, cmCTestHandlerCommand); protected: - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; enum { diff --git a/Source/CTest/cmCTestConfigureHandler.h b/Source/CTest/cmCTestConfigureHandler.h index 4c1a96b..a7de939 100644 --- a/Source/CTest/cmCTestConfigureHandler.h +++ b/Source/CTest/cmCTestConfigureHandler.h @@ -29,11 +29,11 @@ public: /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; cmCTestConfigureHandler(); - void Initialize(); + void Initialize() CM_OVERRIDE; }; #endif diff --git a/Source/CTest/cmCTestCoverageCommand.cxx b/Source/CTest/cmCTestCoverageCommand.cxx index 223d010..86e3ce4 100644 --- a/Source/CTest/cmCTestCoverageCommand.cxx +++ b/Source/CTest/cmCTestCoverageCommand.cxx @@ -30,7 +30,7 @@ cmCTestGenericHandler* cmCTestCoverageCommand::InitializeHandler() this->CTest->GetInitializedHandler("coverage")); if (!handler) { this->SetError("internal CTest error. Cannot instantiate test handler"); - return 0; + return CM_NULLPTR; } // If a LABELS option was given, select only files with the labels. diff --git a/Source/CTest/cmCTestCoverageCommand.h b/Source/CTest/cmCTestCoverageCommand.h index f60ffd5..ffd5fec 100644 --- a/Source/CTest/cmCTestCoverageCommand.h +++ b/Source/CTest/cmCTestCoverageCommand.h @@ -27,7 +27,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestCoverageCommand* ni = new cmCTestCoverageCommand; ni->CTest = this->CTest; @@ -38,15 +38,15 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_coverage"; } + std::string GetName() const CM_OVERRIDE { return "ctest_coverage"; } cmTypeMacro(cmCTestCoverageCommand, cmCTestHandlerCommand); protected: - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; - virtual bool CheckArgumentKeyword(std::string const& arg); - virtual bool CheckArgumentValue(std::string const& arg); + bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE; + bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE; enum { diff --git a/Source/CTest/cmCTestCoverageHandler.cxx b/Source/CTest/cmCTestCoverageHandler.cxx index a631db9..7102533 100644 --- a/Source/CTest/cmCTestCoverageHandler.cxx +++ b/Source/CTest/cmCTestCoverageHandler.cxx @@ -76,7 +76,7 @@ public: i != this->CommandLineStrings.end(); ++i) { args.push_back(i->c_str()); } - args.push_back(0); // null terminate + args.push_back(CM_NULLPTR); // null terminate cmsysProcess_SetCommand(this->Process, &*args.begin()); if (!this->WorkingDirectory.empty()) { cmsysProcess_SetWorkingDirectory(this->Process, @@ -101,7 +101,7 @@ public: { cmsysProcess_SetPipeFile(this->Process, cmsysProcess_Pipe_STDERR, fname); } - int WaitForExit(double* timeout = 0) + int WaitForExit(double* timeout = CM_NULLPTR) { this->PipeState = cmsysProcess_WaitForExit(this->Process, timeout); return this->PipeState; @@ -1781,7 +1781,7 @@ const char* bullseyeHelp[] = { " condition evaluated true or false, respectively.", " * A k indicates a constant decision or condition.", " * The slash / means this probe is excluded from summary results. ", - 0 + CM_NULLPTR }; } @@ -1809,7 +1809,7 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch( cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "run covbr: " << std::endl, this->Quiet); - if (!this->RunBullseyeCommand(cont, "covbr", 0, outputFile)) { + if (!this->RunBullseyeCommand(cont, "covbr", CM_NULLPTR, outputFile)) { cmCTestLog(this->CTest, ERROR_MESSAGE, "error running covbr for." << "\n"); return -1; @@ -1882,7 +1882,7 @@ int cmCTestCoverageHandler::RunBullseyeCoverageBranch( covLogXML.StartElement("Report"); // write the bullseye header line = 0; - for (int k = 0; bullseyeHelp[k] != 0; ++k) { + for (int k = 0; bullseyeHelp[k] != CM_NULLPTR; ++k) { covLogXML.StartElement("Line"); covLogXML.Attribute("Number", line); covLogXML.Attribute("Count", -1); diff --git a/Source/CTest/cmCTestCoverageHandler.h b/Source/CTest/cmCTestCoverageHandler.h index 1773218..60fea48 100644 --- a/Source/CTest/cmCTestCoverageHandler.h +++ b/Source/CTest/cmCTestCoverageHandler.h @@ -45,16 +45,16 @@ public: /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; cmCTestCoverageHandler(); - virtual void Initialize(); + void Initialize() CM_OVERRIDE; /** * This method is called when reading CTest custom file */ - void PopulateCustomVectors(cmMakefile* mf); + void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE; /** Report coverage only for sources with these labels. */ void SetLabelFilter(std::set<std::string> const& labels); diff --git a/Source/CTest/cmCTestCurl.cxx b/Source/CTest/cmCTestCurl.cxx index 4818324..6b8e5b5 100644 --- a/Source/CTest/cmCTestCurl.cxx +++ b/Source/CTest/cmCTestCurl.cxx @@ -147,7 +147,7 @@ bool cmCTestCurl::UploadFile(std::string const& local_file, ::curl_easy_setopt(this->Curl, CURLOPT_DEBUGFUNCTION, curlDebugCallback); // Be sure to set Content-Type to satisfy fussy modsecurity rules struct curl_slist* headers = - ::curl_slist_append(NULL, "Content-Type: text/xml"); + ::curl_slist_append(CM_NULLPTR, "Content-Type: text/xml"); ::curl_easy_setopt(this->Curl, CURLOPT_HTTPHEADER, headers); std::vector<char> responseData; std::vector<char> debugData; diff --git a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h index e904d19..acacbcb 100644 --- a/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h +++ b/Source/CTest/cmCTestEmptyBinaryDirectoryCommand.h @@ -28,7 +28,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestEmptyBinaryDirectoryCommand* ni = new cmCTestEmptyBinaryDirectoryCommand; @@ -41,13 +41,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return "ctest_empty_binary_directory"; } diff --git a/Source/CTest/cmCTestGIT.cxx b/Source/CTest/cmCTestGIT.cxx index 8b392f2..61dbe33 100644 --- a/Source/CTest/cmCTestGIT.cxx +++ b/Source/CTest/cmCTestGIT.cxx @@ -52,7 +52,7 @@ public: private: std::string& Line1; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { // Only the first line is of interest. this->Line1 = this->Line; @@ -64,7 +64,8 @@ std::string cmCTestGIT::GetWorkingRevision() { // Run plumbing "git rev-list" to get work tree revision. const char* git = this->CommandLineTool.c_str(); - const char* git_rev_list[] = { git, "rev-list", "-n", "1", "HEAD", "--", 0 }; + const char* git_rev_list[] = { git, "rev-list", "-n", "1", + "HEAD", "--", CM_NULLPTR }; std::string rev; OneLineParser out(this, "rl-out> ", rev); OutputLogger err(this->Log, "rl-err> "); @@ -93,7 +94,7 @@ std::string cmCTestGIT::FindGitDir() // Run "git rev-parse --git-dir" to locate the real .git directory. const char* git = this->CommandLineTool.c_str(); - char const* git_rev_parse[] = { git, "rev-parse", "--git-dir", 0 }; + char const* git_rev_parse[] = { git, "rev-parse", "--git-dir", CM_NULLPTR }; std::string git_dir_line; OneLineParser rev_parse_out(this, "rev-parse-out> ", git_dir_line); OutputLogger rev_parse_err(this->Log, "rev-parse-err> "); @@ -135,7 +136,8 @@ std::string cmCTestGIT::FindTopDir() // Run "git rev-parse --show-cdup" to locate the top of the tree. const char* git = this->CommandLineTool.c_str(); - char const* git_rev_parse[] = { git, "rev-parse", "--show-cdup", 0 }; + char const* git_rev_parse[] = { git, "rev-parse", "--show-cdup", + CM_NULLPTR }; std::string cdup; OneLineParser rev_parse_out(this, "rev-parse-out> ", cdup); OutputLogger rev_parse_err(this->Log, "rev-parse-err> "); @@ -169,7 +171,7 @@ bool cmCTestGIT::UpdateByFetchAndReset() } // Sentinel argument. - git_fetch.push_back(0); + git_fetch.push_back(CM_NULLPTR); // Fetch upstream refs. OutputLogger fetch_out(this->Log, "fetch-out> "); @@ -204,7 +206,8 @@ bool cmCTestGIT::UpdateByFetchAndReset() } // Reset the local branch to point at that tracked from upstream. - char const* git_reset[] = { git, "reset", "--hard", sha1.c_str(), 0 }; + char const* git_reset[] = { git, "reset", "--hard", sha1.c_str(), + CM_NULLPTR }; OutputLogger reset_out(this->Log, "reset-out> "); OutputLogger reset_err(this->Log, "reset-err> "); return this->RunChild(&git_reset[0], &reset_out, &reset_err); @@ -219,7 +222,7 @@ bool cmCTestGIT::UpdateByCustom(std::string const& custom) i != git_custom_command.end(); ++i) { git_custom.push_back(i->c_str()); } - git_custom.push_back(0); + git_custom.push_back(CM_NULLPTR); OutputLogger custom_out(this->Log, "custom-out> "); OutputLogger custom_err(this->Log, "custom-err> "); @@ -248,7 +251,7 @@ bool cmCTestGIT::UpdateImpl() // Git < 1.6.5 did not support submodule --recursive if (this->GetGitVersion() < cmCTestGITVersion(1, 6, 5, 0)) { - recursive = 0; + recursive = CM_NULLPTR; // No need to require >= 1.6.5 if there are no submodules. if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) { this->Log << "Git < 1.6.5 cannot update submodules recursively\n"; @@ -257,7 +260,7 @@ bool cmCTestGIT::UpdateImpl() // Git < 1.8.1 did not support sync --recursive if (this->GetGitVersion() < cmCTestGITVersion(1, 8, 1, 0)) { - sync_recursive = 0; + sync_recursive = CM_NULLPTR; // No need to require >= 1.8.1 if there are no submodules. if (cmSystemTools::FileExists((top_dir + "/.gitmodules").c_str())) { this->Log << "Git < 1.8.1 cannot synchronize submodules recursively\n"; @@ -272,7 +275,8 @@ bool cmCTestGIT::UpdateImpl() std::string init_submodules = this->CTest->GetCTestConfiguration("GITInitSubmodules"); if (cmSystemTools::IsOn(init_submodules.c_str())) { - char const* git_submodule_init[] = { git, "submodule", "init", 0 }; + char const* git_submodule_init[] = { git, "submodule", "init", + CM_NULLPTR }; ret = this->RunChild(git_submodule_init, &submodule_out, &submodule_err, top_dir.c_str()); @@ -282,7 +286,7 @@ bool cmCTestGIT::UpdateImpl() } char const* git_submodule_sync[] = { git, "submodule", "sync", - sync_recursive, 0 }; + sync_recursive, CM_NULLPTR }; ret = this->RunChild(git_submodule_sync, &submodule_out, &submodule_err, top_dir.c_str()); @@ -290,7 +294,8 @@ bool cmCTestGIT::UpdateImpl() return false; } - char const* git_submodule[] = { git, "submodule", "update", recursive, 0 }; + char const* git_submodule[] = { git, "submodule", "update", recursive, + CM_NULLPTR }; return this->RunChild(git_submodule, &submodule_out, &submodule_err, top_dir.c_str()); } @@ -299,7 +304,7 @@ unsigned int cmCTestGIT::GetGitVersion() { if (!this->CurrentGitVersion) { const char* git = this->CommandLineTool.c_str(); - char const* git_version[] = { git, "--version", 0 }; + char const* git_version[] = { git, "--version", CM_NULLPTR }; std::string version; OneLineParser version_out(this, "version-out> ", version); OutputLogger version_err(this->Log, "version-err> "); @@ -355,7 +360,7 @@ protected: this->Changes.clear(); } - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->Line[0] == ':') { this->DiffField = DiffFieldChange; @@ -513,7 +518,7 @@ private: person.TimeZone = strtol(c, (char**)&c, 10); } - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->Line.empty()) { if (this->Section == SectionBody && this->LineEnd == '\0') { @@ -611,10 +616,10 @@ void cmCTestGIT::LoadRevisions() std::string range = this->OldRevision + ".." + this->NewRevision; const char* git = this->CommandLineTool.c_str(); const char* git_rev_list[] = { git, "rev-list", "--reverse", - range.c_str(), "--", 0 }; + range.c_str(), "--", CM_NULLPTR }; const char* git_diff_tree[] = { git, "diff-tree", "--stdin", "--always", "-z", - "-r", "--pretty=raw", "--encoding=utf-8", 0 + "-r", "--pretty=raw", "--encoding=utf-8", CM_NULLPTR }; this->Log << this->ComputeCommandLine(git_rev_list) << " | " << this->ComputeCommandLine(git_diff_tree) << "\n"; @@ -639,13 +644,15 @@ void cmCTestGIT::LoadModifications() const char* git = this->CommandLineTool.c_str(); // Use 'git update-index' to refresh the index w.r.t. the work tree. - const char* git_update_index[] = { git, "update-index", "--refresh", 0 }; + const char* git_update_index[] = { git, "update-index", "--refresh", + CM_NULLPTR }; OutputLogger ui_out(this->Log, "ui-out> "); OutputLogger ui_err(this->Log, "ui-err> "); this->RunChild(git_update_index, &ui_out, &ui_err); // Use 'git diff-index' to get modified files. - const char* git_diff_index[] = { git, "diff-index", "-z", "HEAD", "--", 0 }; + const char* git_diff_index[] = { git, "diff-index", "-z", + "HEAD", "--", CM_NULLPTR }; DiffParser out(this, "di-out> "); OutputLogger err(this->Log, "di-err> "); this->RunChild(git_diff_index, &out, &err); diff --git a/Source/CTest/cmCTestGIT.h b/Source/CTest/cmCTestGIT.h index 685cc31..85298cb 100644 --- a/Source/CTest/cmCTestGIT.h +++ b/Source/CTest/cmCTestGIT.h @@ -24,15 +24,15 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestGIT(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestGIT(); + ~cmCTestGIT() CM_OVERRIDE; private: unsigned int CurrentGitVersion; unsigned int GetGitVersion(); std::string GetWorkingRevision(); - virtual void NoteOldRevision(); - virtual void NoteNewRevision(); - virtual bool UpdateImpl(); + void NoteOldRevision() CM_OVERRIDE; + void NoteNewRevision() CM_OVERRIDE; + bool UpdateImpl() CM_OVERRIDE; std::string FindGitDir(); std::string FindTopDir(); @@ -41,8 +41,8 @@ private: bool UpdateByCustom(std::string const& custom); bool UpdateInternal(); - void LoadRevisions(); - void LoadModifications(); + void LoadRevisions() CM_OVERRIDE; + void LoadModifications() CM_OVERRIDE; // "public" needed by older Sun compilers public: diff --git a/Source/CTest/cmCTestGenericHandler.cxx b/Source/CTest/cmCTestGenericHandler.cxx index 18caabe..7755ee9 100644 --- a/Source/CTest/cmCTestGenericHandler.cxx +++ b/Source/CTest/cmCTestGenericHandler.cxx @@ -19,7 +19,7 @@ cmCTestGenericHandler::cmCTestGenericHandler() { this->HandlerVerbose = cmSystemTools::OUTPUT_NONE; - this->CTest = 0; + this->CTest = CM_NULLPTR; this->SubmitIndex = 0; this->AppendXML = false; this->Quiet = false; @@ -77,7 +77,7 @@ const char* cmCTestGenericHandler::GetOption(const std::string& op) cmCTestGenericHandler::t_StringToString::iterator remit = this->Options.find(op); if (remit == this->Options.end()) { - return 0; + return CM_NULLPTR; } return remit->second.c_str(); } diff --git a/Source/CTest/cmCTestGenericHandler.h b/Source/CTest/cmCTestGenericHandler.h index ad349ac..9949c3a 100644 --- a/Source/CTest/cmCTestGenericHandler.h +++ b/Source/CTest/cmCTestGenericHandler.h @@ -74,7 +74,7 @@ public: * Construct handler */ cmCTestGenericHandler(); - virtual ~cmCTestGenericHandler(); + ~cmCTestGenericHandler() CM_OVERRIDE; typedef std::map<std::string, std::string> t_StringToString; diff --git a/Source/CTest/cmCTestGlobalVC.h b/Source/CTest/cmCTestGlobalVC.h index 9a5357f..7ea3440 100644 --- a/Source/CTest/cmCTestGlobalVC.h +++ b/Source/CTest/cmCTestGlobalVC.h @@ -26,11 +26,11 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestGlobalVC(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestGlobalVC(); + ~cmCTestGlobalVC() CM_OVERRIDE; protected: // Implement cmCTestVC internal API. - virtual bool WriteXMLUpdates(cmXMLWriter& xml); + bool WriteXMLUpdates(cmXMLWriter& xml) CM_OVERRIDE; /** Represent a vcs-reported action for one path in a revision. */ struct Change diff --git a/Source/CTest/cmCTestHG.cxx b/Source/CTest/cmCTestHG.cxx index f1fe377..eb3d611 100644 --- a/Source/CTest/cmCTestHG.cxx +++ b/Source/CTest/cmCTestHG.cxx @@ -41,7 +41,7 @@ private: std::string& Rev; cmsys::RegularExpression RegexIdentify; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexIdentify.find(this->Line)) { this->Rev = this->RegexIdentify.match(1); @@ -65,7 +65,7 @@ private: cmCTestHG* HG; cmsys::RegularExpression RegexStatus; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexStatus.find(this->Line)) { this->DoPath(this->RegexStatus.match(1)[0], this->RegexStatus.match(2)); @@ -101,7 +101,7 @@ std::string cmCTestHG::GetWorkingRevision() { // Run plumbing "hg identify" to get work tree revision. const char* hg = this->CommandLineTool.c_str(); - const char* hg_identify[] = { hg, "identify", "-i", 0 }; + const char* hg_identify[] = { hg, "identify", "-i", CM_NULLPTR }; std::string rev; IdentifyParser out(this, "rev-out> ", rev); OutputLogger err(this->Log, "rev-err> "); @@ -129,7 +129,7 @@ bool cmCTestHG::UpdateImpl() // Use "hg pull" followed by "hg update" to update the working tree. { const char* hg = this->CommandLineTool.c_str(); - const char* hg_pull[] = { hg, "pull", "-v", 0 }; + const char* hg_pull[] = { hg, "pull", "-v", CM_NULLPTR }; OutputLogger out(this->Log, "pull-out> "); OutputLogger err(this->Log, "pull-err> "); this->RunChild(&hg_pull[0], &out, &err); @@ -154,7 +154,7 @@ bool cmCTestHG::UpdateImpl() } // Sentinel argument. - hg_update.push_back(0); + hg_update.push_back(CM_NULLPTR); OutputLogger out(this->Log, "update-out> "); OutputLogger err(this->Log, "update-err> "); @@ -171,7 +171,7 @@ public: { this->InitializeParser(); } - ~LogParser() { this->CleanupParser(); } + ~LogParser() CM_OVERRIDE { this->CleanupParser(); } private: cmCTestHG* HG; @@ -182,14 +182,14 @@ private: Change CurChange; std::vector<char> CData; - virtual bool ProcessChunk(const char* data, int length) + bool ProcessChunk(const char* data, int length) CM_OVERRIDE { this->OutputLogger::ProcessChunk(data, length); this->ParseChunk(data, length); return true; } - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { this->CData.clear(); if (name == "logentry") { @@ -201,12 +201,12 @@ private: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { this->CData.insert(this->CData.end(), data, data + length); } - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "logentry") { this->HG->DoRevision(this->Rev, this->Changes); @@ -261,7 +261,7 @@ private: return output; } - virtual void ReportError(int, int, const char* msg) + void ReportError(int, int, const char* msg) CM_OVERRIDE { this->HG->Log << "Error parsing hg log xml: " << msg << "\n"; } @@ -288,7 +288,8 @@ void cmCTestHG::LoadRevisions() " <file_dels>{file_dels}</file_dels>\n" "</logentry>\n"; const char* hg_log[] = { - hg, "log", "--removed", "-r", range.c_str(), "--template", hgXMLTemplate, 0 + hg, "log", "--removed", "-r", range.c_str(), + "--template", hgXMLTemplate, CM_NULLPTR }; LogParser out(this, "log-out> "); @@ -303,7 +304,7 @@ void cmCTestHG::LoadModifications() { // Use 'hg status' to get modified files. const char* hg = this->CommandLineTool.c_str(); - const char* hg_status[] = { hg, "status", 0 }; + const char* hg_status[] = { hg, "status", CM_NULLPTR }; StatusParser out(this, "status-out> "); OutputLogger err(this->Log, "status-err> "); this->RunChild(hg_status, &out, &err); diff --git a/Source/CTest/cmCTestHG.h b/Source/CTest/cmCTestHG.h index 8cc8c7a..c4ce08c 100644 --- a/Source/CTest/cmCTestHG.h +++ b/Source/CTest/cmCTestHG.h @@ -24,16 +24,16 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestHG(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestHG(); + ~cmCTestHG() CM_OVERRIDE; private: std::string GetWorkingRevision(); - virtual void NoteOldRevision(); - virtual void NoteNewRevision(); - virtual bool UpdateImpl(); + void NoteOldRevision() CM_OVERRIDE; + void NoteNewRevision() CM_OVERRIDE; + bool UpdateImpl() CM_OVERRIDE; - void LoadRevisions(); - void LoadModifications(); + void LoadRevisions() CM_OVERRIDE; + void LoadModifications() CM_OVERRIDE; // Parsing helper classes. class IdentifyParser; diff --git a/Source/CTest/cmCTestHandlerCommand.cxx b/Source/CTest/cmCTestHandlerCommand.cxx index 76f971d..e1361a1 100644 --- a/Source/CTest/cmCTestHandlerCommand.cxx +++ b/Source/CTest/cmCTestHandlerCommand.cxx @@ -20,7 +20,7 @@ cmCTestHandlerCommand::cmCTestHandlerCommand() size_t cc; this->Arguments.reserve(INIT_SIZE); for (cc = 0; cc < INIT_SIZE; ++cc) { - this->Arguments.push_back(0); + this->Arguments.push_back(CM_NULLPTR); } this->Arguments[ct_RETURN_VALUE] = "RETURN_VALUE"; this->Arguments[ct_SOURCE] = "SOURCE"; @@ -36,7 +36,7 @@ bool cmCTestHandlerCommand::InitialPass(std::vector<std::string> const& args, { // Allocate space for argument values. this->Values.clear(); - this->Values.resize(this->Last, 0); + this->Values.resize(this->Last, CM_NULLPTR); // Process input arguments. this->ArgumentDoing = ArgumentDoingNone; diff --git a/Source/CTest/cmCTestHandlerCommand.h b/Source/CTest/cmCTestHandlerCommand.h index 7248832..0468bbc 100644 --- a/Source/CTest/cmCTestHandlerCommand.h +++ b/Source/CTest/cmCTestHandlerCommand.h @@ -30,8 +30,8 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; cmTypeMacro(cmCTestHandlerCommand, cmCTestCommand); diff --git a/Source/CTest/cmCTestLaunch.cxx b/Source/CTest/cmCTestLaunch.cxx index 99fa9e7..3eed79e 100644 --- a/Source/CTest/cmCTestLaunch.cxx +++ b/Source/CTest/cmCTestLaunch.cxx @@ -30,7 +30,7 @@ cmCTestLaunch::cmCTestLaunch(int argc, const char* const* argv) { this->Passthru = true; - this->Process = 0; + this->Process = CM_NULLPTR; this->ExitCode = 1; this->CWD = cmSystemTools::GetCurrentWorkingDirectory(); @@ -128,7 +128,7 @@ bool cmCTestLaunch::ParseArguments(int argc, const char* const* argv) return true; } else { this->RealArgC = 0; - this->RealArgV = 0; + this->RealArgV = CM_NULLPTR; std::cerr << "No launch/command separator ('--') found!\n"; return false; } @@ -227,9 +227,9 @@ void cmCTestLaunch::RunChild() // Record child stdout and stderr if necessary. if (!this->Passthru) { - char* data = 0; + char* data = CM_NULLPTR; int length = 0; - while (int p = cmsysProcess_WaitForData(cp, &data, &length, 0)) { + while (int p = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR)) { if (p == cmsysProcess_Pipe_STDOUT) { fout.write(data, length); std::cout.write(data, length); @@ -243,7 +243,7 @@ void cmCTestLaunch::RunChild() } // Wait for the real command to finish. - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); this->ExitCode = cmsysProcess_GetExitValue(cp); } @@ -384,7 +384,7 @@ void cmCTestLaunch::WriteXMLAction(cmXMLWriter& xml) } // OutputType - const char* outputType = 0; + const char* outputType = CM_NULLPTR; if (!this->OptionTargetType.empty()) { if (this->OptionTargetType == "EXECUTABLE") { outputType = "executable"; @@ -612,7 +612,7 @@ int cmCTestLaunch::Main(int argc, const char* const argv[]) #include "cmGlobalGenerator.h" #include "cmMakefile.h" #include "cmake.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> void cmCTestLaunch::LoadConfig() { cmake cm; @@ -620,7 +620,7 @@ void cmCTestLaunch::LoadConfig() cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); std::string fname = this->LogDir; fname += "CTestLaunchConfig.cmake"; if (cmSystemTools::FileExists(fname.c_str()) && diff --git a/Source/CTest/cmCTestMemCheckCommand.h b/Source/CTest/cmCTestMemCheckCommand.h index 245892c..2ba33ae 100644 --- a/Source/CTest/cmCTestMemCheckCommand.h +++ b/Source/CTest/cmCTestMemCheckCommand.h @@ -29,7 +29,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestMemCheckCommand* ni = new cmCTestMemCheckCommand; ni->CTest = this->CTest; @@ -40,12 +40,12 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_memcheck"; } + std::string GetName() const CM_OVERRIDE { return "ctest_memcheck"; } cmTypeMacro(cmCTestMemCheckCommand, cmCTestTestCommand); protected: - cmCTestGenericHandler* InitializeActualHandler(); + cmCTestGenericHandler* InitializeActualHandler() CM_OVERRIDE; }; #endif diff --git a/Source/CTest/cmCTestMemCheckHandler.cxx b/Source/CTest/cmCTestMemCheckHandler.cxx index 5f70f66..dfa8a1a 100644 --- a/Source/CTest/cmCTestMemCheckHandler.cxx +++ b/Source/CTest/cmCTestMemCheckHandler.cxx @@ -42,7 +42,7 @@ static CatToErrorType cmCTestMemCheckBoundsChecker[] = { { "Allocation Conflict", cmCTestMemCheckHandler::FMM }, { "Bad Pointer Use", cmCTestMemCheckHandler::FMW }, { "Dangling Pointer", cmCTestMemCheckHandler::FMR }, - { 0, 0 } + { CM_NULLPTR, 0 } }; static void xmlReportError(int line, const char* msg, void* data) @@ -61,7 +61,7 @@ public: this->CTest = c; this->SetErrorCallback(xmlReportError, (void*)c); } - void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { if (name == "MemoryLeak" || name == "ResourceLeak") { this->Errors.push_back(cmCTestMemCheckHandler::MLK); @@ -72,23 +72,23 @@ public: std::ostringstream ostr; ostr << name << ":\n"; int i = 0; - for (; atts[i] != 0; i += 2) { + for (; atts[i] != CM_NULLPTR; i += 2) { ostr << " " << atts[i] << " - " << atts[i + 1] << "\n"; } ostr << "\n"; this->Log += ostr.str(); } - void EndElement(const std::string&) {} + void EndElement(const std::string&) CM_OVERRIDE {} const char* GetAttribute(const char* name, const char** atts) { int i = 0; - for (; atts[i] != 0; ++i) { + for (; atts[i] != CM_NULLPTR; ++i) { if (strcmp(name, atts[i]) == 0) { return atts[i + 1]; } } - return 0; + return CM_NULLPTR; } void ParseError(const char** atts) { @@ -241,9 +241,9 @@ void cmCTestMemCheckHandler::InitializeResultsVectors() // define the standard set of errors //---------------------------------------------------------------------- static const char* cmCTestMemCheckResultStrings[] = { - "ABR", "ABW", "ABWL", "COR", "EXU", "FFM", "FIM", "FMM", - "FMR", "FMW", "FUM", "IPR", "IPW", "MAF", "MLK", "MPK", - "NPR", "ODS", "PAR", "PLK", "UMC", "UMR", 0 + "ABR", "ABW", "ABWL", "COR", "EXU", "FFM", "FIM", "FMM", + "FMR", "FMW", "FUM", "IPR", "IPW", "MAF", "MLK", "MPK", + "NPR", "ODS", "PAR", "PLK", "UMC", "UMR", CM_NULLPTR }; static const char* cmCTestMemCheckResultLongStrings[] = { "Threading Problem", @@ -268,10 +268,10 @@ void cmCTestMemCheckHandler::InitializeResultsVectors() "PLK", "Uninitialized Memory Conditional", "Uninitialized Memory Read", - 0 + CM_NULLPTR }; this->GlobalResults.clear(); - for (int i = 0; cmCTestMemCheckResultStrings[i] != 0; ++i) { + for (int i = 0; cmCTestMemCheckResultStrings[i] != CM_NULLPTR; ++i) { this->ResultStrings.push_back(cmCTestMemCheckResultStrings[i]); this->ResultStringsLong.push_back(cmCTestMemCheckResultLongStrings[i]); this->GlobalResults.push_back(0); diff --git a/Source/CTest/cmCTestMemCheckHandler.h b/Source/CTest/cmCTestMemCheckHandler.h index 8f0cc47..a005d54 100644 --- a/Source/CTest/cmCTestMemCheckHandler.h +++ b/Source/CTest/cmCTestMemCheckHandler.h @@ -33,16 +33,17 @@ class cmCTestMemCheckHandler : public cmCTestTestHandler public: cmTypeMacro(cmCTestMemCheckHandler, cmCTestTestHandler); - void PopulateCustomVectors(cmMakefile* mf); + void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE; cmCTestMemCheckHandler(); - void Initialize(); + void Initialize() CM_OVERRIDE; protected: - virtual int PreProcessHandler(); - virtual int PostProcessHandler(); - virtual void GenerateTestCommand(std::vector<std::string>& args, int test); + int PreProcessHandler() CM_OVERRIDE; + int PostProcessHandler() CM_OVERRIDE; + void GenerateTestCommand(std::vector<std::string>& args, + int test) CM_OVERRIDE; private: enum @@ -125,7 +126,7 @@ private: /** * Generate the Dart compatible output */ - void GenerateDartOutput(cmXMLWriter& xml); + void GenerateDartOutput(cmXMLWriter& xml) CM_OVERRIDE; std::vector<std::string> CustomPreMemCheck; std::vector<std::string> CustomPostMemCheck; diff --git a/Source/CTest/cmCTestP4.cxx b/Source/CTest/cmCTestP4.cxx index ede11c9..d4a32f1 100644 --- a/Source/CTest/cmCTestP4.cxx +++ b/Source/CTest/cmCTestP4.cxx @@ -45,7 +45,7 @@ private: std::string& Rev; cmsys::RegularExpression RegexIdentify; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexIdentify.find(this->Line)) { this->Rev = this->RegexIdentify.match(1); @@ -69,7 +69,7 @@ private: cmsys::RegularExpression RegexIdentify; cmCTestP4* P4; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexIdentify.find(this->Line)) { P4->ChangeLists.push_back(this->RegexIdentify.match(1)); @@ -92,7 +92,7 @@ private: cmsys::RegularExpression RegexUser; cmCTestP4* P4; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexUser.find(this->Line)) { User NewUser; @@ -135,7 +135,7 @@ private: std::string CurrentPath; cmsys::RegularExpression RegexDiff; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (!this->Line.empty() && this->Line[0] == '=' && this->RegexDiff.find(this->Line)) { @@ -163,7 +163,7 @@ cmCTestP4::User cmCTestP4::GetUserData(const std::string& username) p4_users.push_back("-m"); p4_users.push_back("1"); p4_users.push_back(username.c_str()); - p4_users.push_back(0); + p4_users.push_back(CM_NULLPTR); UserParser out(this, "users-out> "); OutputLogger err(this->Log, "users-err> "); @@ -225,7 +225,7 @@ private: SectionType Section; Revision Rev; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->Line.empty()) { this->NextSection(); @@ -358,7 +358,7 @@ std::string cmCTestP4::GetWorkingRevision() std::string source = this->SourceDirectory + "/...#have"; p4_identify.push_back(source.c_str()); - p4_identify.push_back(0); + p4_identify.push_back(CM_NULLPTR); std::string rev; IdentifyParser out(this, "p4_changes-out> ", rev); @@ -418,7 +418,7 @@ void cmCTestP4::LoadRevisions() p4_changes.push_back("changes"); p4_changes.push_back(range.c_str()); - p4_changes.push_back(0); + p4_changes.push_back(CM_NULLPTR); ChangesParser out(this, "p4_changes-out> "); OutputLogger err(this->Log, "p4_changes-err> "); @@ -438,7 +438,7 @@ void cmCTestP4::LoadRevisions() p4_describe.push_back("describe"); p4_describe.push_back("-s"); p4_describe.push_back(i->c_str()); - p4_describe.push_back(0); + p4_describe.push_back(CM_NULLPTR); DescribeParser outDescribe(this, "p4_describe-out> "); OutputLogger errDescribe(this->Log, "p4_describe-err> "); @@ -457,7 +457,7 @@ void cmCTestP4::LoadModifications() p4_diff.push_back("-dn"); std::string source = this->SourceDirectory + "/..."; p4_diff.push_back(source.c_str()); - p4_diff.push_back(0); + p4_diff.push_back(CM_NULLPTR); DiffParser out(this, "p4_diff-out> "); OutputLogger err(this->Log, "p4_diff-err> "); @@ -474,7 +474,7 @@ bool cmCTestP4::UpdateCustom(const std::string& custom) i != p4_custom_command.end(); ++i) { p4_custom.push_back(i->c_str()); } - p4_custom.push_back(0); + p4_custom.push_back(CM_NULLPTR); OutputLogger custom_out(this->Log, "p4_customsync-out> "); OutputLogger custom_err(this->Log, "p4_customsync-err> "); @@ -525,7 +525,7 @@ bool cmCTestP4::UpdateImpl() } p4_sync.push_back(source.c_str()); - p4_sync.push_back(0); + p4_sync.push_back(CM_NULLPTR); OutputLogger out(this->Log, "p4_sync-out> "); OutputLogger err(this->Log, "p4_sync-err> "); diff --git a/Source/CTest/cmCTestP4.h b/Source/CTest/cmCTestP4.h index 917751e..84e4f96 100644 --- a/Source/CTest/cmCTestP4.h +++ b/Source/CTest/cmCTestP4.h @@ -27,7 +27,7 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestP4(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestP4(); + ~cmCTestP4() CM_OVERRIDE; private: std::vector<std::string> ChangeLists; @@ -54,13 +54,13 @@ private: void SetP4Options(std::vector<char const*>& options); std::string GetWorkingRevision(); - virtual void NoteOldRevision(); - virtual void NoteNewRevision(); - virtual bool UpdateImpl(); + void NoteOldRevision() CM_OVERRIDE; + void NoteNewRevision() CM_OVERRIDE; + bool UpdateImpl() CM_OVERRIDE; bool UpdateCustom(const std::string& custom); - void LoadRevisions(); - void LoadModifications(); + void LoadRevisions() CM_OVERRIDE; + void LoadModifications() CM_OVERRIDE; // Parsing helper classes. class IdentifyParser; diff --git a/Source/CTest/cmCTestReadCustomFilesCommand.h b/Source/CTest/cmCTestReadCustomFilesCommand.h index 713fc66..6cce7c8 100644 --- a/Source/CTest/cmCTestReadCustomFilesCommand.h +++ b/Source/CTest/cmCTestReadCustomFilesCommand.h @@ -28,7 +28,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestReadCustomFilesCommand* ni = new cmCTestReadCustomFilesCommand; ni->CTest = this->CTest; @@ -39,13 +39,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_read_custom_files"; } + std::string GetName() const CM_OVERRIDE { return "ctest_read_custom_files"; } cmTypeMacro(cmCTestReadCustomFilesCommand, cmCTestCommand); }; diff --git a/Source/CTest/cmCTestRunScriptCommand.h b/Source/CTest/cmCTestRunScriptCommand.h index c503516..9ea0999 100644 --- a/Source/CTest/cmCTestRunScriptCommand.h +++ b/Source/CTest/cmCTestRunScriptCommand.h @@ -28,7 +28,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestRunScriptCommand* ni = new cmCTestRunScriptCommand; ni->CTest = this->CTest; @@ -40,13 +40,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_run_script"; } + std::string GetName() const CM_OVERRIDE { return "ctest_run_script"; } cmTypeMacro(cmCTestRunScriptCommand, cmCTestCommand); }; diff --git a/Source/CTest/cmCTestRunTest.cxx b/Source/CTest/cmCTestRunTest.cxx index 48582c9..9e3802a 100644 --- a/Source/CTest/cmCTestRunTest.cxx +++ b/Source/CTest/cmCTestRunTest.cxx @@ -24,12 +24,12 @@ cmCTestRunTest::cmCTestRunTest(cmCTestTestHandler* handler) { this->CTest = handler->CTest; this->TestHandler = handler; - this->TestProcess = 0; + this->TestProcess = CM_NULLPTR; this->TestResult.ExecutionTime = 0; this->TestResult.ReturnValue = 0; this->TestResult.Status = cmCTestTestHandler::NOT_RUN; this->TestResult.TestCount = 0; - this->TestResult.Properties = 0; + this->TestResult.Properties = CM_NULLPTR; this->ProcessOutput = ""; this->CompressedOutput = ""; this->CompressionRatio = 2; @@ -577,7 +577,7 @@ double cmCTestRunTest::ResolveTimeout() return timeout; } struct tm* lctime; - time_t current_time = time(0); + time_t current_time = time(CM_NULLPTR); lctime = gmtime(¤t_time); int gm_hour = lctime->tm_hour; time_t gm_time = mktime(lctime); diff --git a/Source/CTest/cmCTestSVN.cxx b/Source/CTest/cmCTestSVN.cxx index fa01411..eae0c6c 100644 --- a/Source/CTest/cmCTestSVN.cxx +++ b/Source/CTest/cmCTestSVN.cxx @@ -62,7 +62,7 @@ private: cmsys::RegularExpression RegexRev; cmsys::RegularExpression RegexURL; cmsys::RegularExpression RegexRoot; - virtual bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexRev.find(this->Line)) { this->Rev = this->RegexRev.match(1); @@ -206,7 +206,7 @@ private: cmCTestSVN* SVN; cmsys::RegularExpression RegexUpdate; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexUpdate.find(this->Line)) { this->DoPath(this->RegexUpdate.match(1)[0], @@ -291,7 +291,7 @@ bool cmCTestSVN::RunSVNCommand(std::vector<char const*> const& parameters, args.push_back(i->c_str()); } - args.push_back(0); + args.push_back(CM_NULLPTR); if (strcmp(parameters[0], "update") == 0) { return RunUpdateCommand(&args[0], out, err); @@ -311,7 +311,7 @@ public: { this->InitializeParser(); } - ~LogParser() { this->CleanupParser(); } + ~LogParser() CM_OVERRIDE { this->CleanupParser(); } private: cmCTestSVN* SVN; cmCTestSVN::SVNInfo& SVNRepo; @@ -323,14 +323,14 @@ private: Change CurChange; std::vector<char> CData; - virtual bool ProcessChunk(const char* data, int length) + bool ProcessChunk(const char* data, int length) CM_OVERRIDE { this->OutputLogger::ProcessChunk(data, length); this->ParseChunk(data, length); return true; } - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { this->CData.clear(); if (name == "logentry") { @@ -348,12 +348,12 @@ private: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { this->CData.insert(this->CData.end(), data, data + length); } - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "logentry") { this->SVN->DoRevisionSVN(this->Rev, this->Changes); @@ -372,7 +372,7 @@ private: this->CData.clear(); } - virtual void ReportError(int, int, const char* msg) + void ReportError(int, int, const char* msg) CM_OVERRIDE { this->SVN->Log << "Error parsing svn log xml: " << msg << "\n"; } @@ -441,7 +441,7 @@ public: private: cmCTestSVN* SVN; cmsys::RegularExpression RegexStatus; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexStatus.find(this->Line)) { this->DoPath(this->RegexStatus.match(1)[0], @@ -506,7 +506,7 @@ public: private: cmCTestSVN* SVN; cmsys::RegularExpression RegexExternal; - bool ProcessLine() + bool ProcessLine() CM_OVERRIDE { if (this->RegexExternal.find(this->Line)) { this->DoPath(this->RegexExternal.match(1)); diff --git a/Source/CTest/cmCTestSVN.h b/Source/CTest/cmCTestSVN.h index e596bdc..4f3eb88 100644 --- a/Source/CTest/cmCTestSVN.h +++ b/Source/CTest/cmCTestSVN.h @@ -26,14 +26,14 @@ public: /** Construct with a CTest instance and update log stream. */ cmCTestSVN(cmCTest* ctest, std::ostream& log); - virtual ~cmCTestSVN(); + ~cmCTestSVN() CM_OVERRIDE; private: // Implement cmCTestVC internal API. - virtual void CleanupImpl(); - virtual void NoteOldRevision(); - virtual void NoteNewRevision(); - virtual bool UpdateImpl(); + void CleanupImpl() CM_OVERRIDE; + void NoteOldRevision() CM_OVERRIDE; + void NoteNewRevision() CM_OVERRIDE; + bool UpdateImpl() CM_OVERRIDE; bool RunSVNCommand(std::vector<char const*> const& parameters, OutputParser* out, OutputParser* err); @@ -78,8 +78,8 @@ private: std::string LoadInfo(SVNInfo& svninfo); void LoadExternals(); - void LoadModifications(); - void LoadRevisions(); + void LoadModifications() CM_OVERRIDE; + void LoadRevisions() CM_OVERRIDE; void LoadRevisions(SVNInfo& svninfo); void GuessBase(SVNInfo& svninfo, std::vector<Change> const& changes); @@ -87,7 +87,7 @@ private: void DoRevisionSVN(Revision const& revision, std::vector<Change> const& changes); - void WriteXMLGlobal(cmXMLWriter& xml); + void WriteXMLGlobal(cmXMLWriter& xml) CM_OVERRIDE; // Parsing helper classes. class InfoParser; diff --git a/Source/CTest/cmCTestScriptHandler.cxx b/Source/CTest/cmCTestScriptHandler.cxx index 6389a9d..b747c64 100644 --- a/Source/CTest/cmCTestScriptHandler.cxx +++ b/Source/CTest/cmCTestScriptHandler.cxx @@ -59,9 +59,9 @@ class cmCTestScriptFunctionBlocker : public cmFunctionBlocker { public: cmCTestScriptFunctionBlocker() {} - virtual ~cmCTestScriptFunctionBlocker() {} - virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, - cmExecutionStatus&); + ~cmCTestScriptFunctionBlocker() CM_OVERRIDE {} + bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; // virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile &mf); // virtual void ScopeEnded(cmMakefile &mf); @@ -82,9 +82,9 @@ cmCTestScriptHandler::cmCTestScriptHandler() this->Backup = false; this->EmptyBinDir = false; this->EmptyBinDirOnce = false; - this->Makefile = 0; - this->CMake = 0; - this->GlobalGenerator = 0; + this->Makefile = CM_NULLPTR; + this->CMake = CM_NULLPTR; + this->GlobalGenerator = CM_NULLPTR; this->ScriptStartTime = 0; @@ -121,10 +121,10 @@ void cmCTestScriptHandler::Initialize() this->ScriptStartTime = 0; delete this->Makefile; - this->Makefile = 0; + this->Makefile = CM_NULLPTR; delete this->GlobalGenerator; - this->GlobalGenerator = 0; + this->GlobalGenerator = CM_NULLPTR; delete this->CMake; } @@ -200,7 +200,7 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg) for (size_t i = 1; i < initArgs.size(); ++i) { argv.push_back(initArgs[i].c_str()); } - argv.push_back(0); + argv.push_back(CM_NULLPTR); // Now create process object cmsysProcess* cp = cmsysProcess_New(); @@ -226,7 +226,7 @@ int cmCTestScriptHandler::ExecuteScript(const std::string& total_script_arg) } // Properly handle output of the build command - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); int result = cmsysProcess_GetState(cp); int retVal = 0; bool failed = false; @@ -863,7 +863,7 @@ bool cmCTestScriptHandler::WriteInitialCache(const char* directory, return false; } - if (text != 0) { + if (text != CM_NULLPTR) { fout.write(text, strlen(text)); } diff --git a/Source/CTest/cmCTestScriptHandler.h b/Source/CTest/cmCTestScriptHandler.h index e09e040..4403030 100644 --- a/Source/CTest/cmCTestScriptHandler.h +++ b/Source/CTest/cmCTestScriptHandler.h @@ -71,7 +71,7 @@ public: /** * Run a dashboard using a specified confiuration script */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; /* * Run a script @@ -104,9 +104,9 @@ public: double GetRemainingTimeAllowed(); cmCTestScriptHandler(); - ~cmCTestScriptHandler(); + ~cmCTestScriptHandler() CM_OVERRIDE; - void Initialize(); + void Initialize() CM_OVERRIDE; void CreateCMake(); cmake* GetCMake() { return this->CMake; } diff --git a/Source/CTest/cmCTestSleepCommand.h b/Source/CTest/cmCTestSleepCommand.h index ff7f146..7981fa2 100644 --- a/Source/CTest/cmCTestSleepCommand.h +++ b/Source/CTest/cmCTestSleepCommand.h @@ -28,7 +28,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestSleepCommand* ni = new cmCTestSleepCommand; ni->CTest = this->CTest; @@ -40,13 +40,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_sleep"; } + std::string GetName() const CM_OVERRIDE { return "ctest_sleep"; } cmTypeMacro(cmCTestSleepCommand, cmCTestCommand); }; diff --git a/Source/CTest/cmCTestStartCommand.cxx b/Source/CTest/cmCTestStartCommand.cxx index 99d431a..c64d16b 100644 --- a/Source/CTest/cmCTestStartCommand.cxx +++ b/Source/CTest/cmCTestStartCommand.cxx @@ -32,12 +32,12 @@ bool cmCTestStartCommand::InitialPass(std::vector<std::string> const& args, size_t cnt = 0; const char* smodel = args[cnt].c_str(); - const char* src_dir = 0; - const char* bld_dir = 0; + const char* src_dir = CM_NULLPTR; + const char* bld_dir = CM_NULLPTR; cnt++; - this->CTest->SetSpecificTrack(0); + this->CTest->SetSpecificTrack(CM_NULLPTR); if (cnt < args.size() - 1) { if (args[cnt] == "TRACK") { cnt++; diff --git a/Source/CTest/cmCTestStartCommand.h b/Source/CTest/cmCTestStartCommand.h index 2aa6281..e3f8f8b 100644 --- a/Source/CTest/cmCTestStartCommand.h +++ b/Source/CTest/cmCTestStartCommand.h @@ -27,7 +27,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestStartCommand* ni = new cmCTestStartCommand; ni->CTest = this->CTest; @@ -41,8 +41,8 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * Will this invocation of ctest_start create a new TAG file? @@ -57,7 +57,7 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_start"; } + std::string GetName() const CM_OVERRIDE { return "ctest_start"; } cmTypeMacro(cmCTestStartCommand, cmCTestCommand); diff --git a/Source/CTest/cmCTestSubmitCommand.cxx b/Source/CTest/cmCTestSubmitCommand.cxx index 664552a..54da383 100644 --- a/Source/CTest/cmCTestSubmitCommand.cxx +++ b/Source/CTest/cmCTestSubmitCommand.cxx @@ -88,7 +88,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler() extraFiles.end()); if (!this->CTest->SubmitExtraFiles(newExtraFiles)) { this->SetError("problem submitting extra files."); - return 0; + return CM_NULLPTR; } } @@ -96,7 +96,7 @@ cmCTestGenericHandler* cmCTestSubmitCommand::InitializeHandler() this->CTest->GetInitializedHandler("submit"); if (!handler) { this->SetError("internal CTest error. Cannot instantiate submit handler"); - return 0; + return CM_NULLPTR; } // If no FILES or PARTS given, *all* PARTS are submitted by default. diff --git a/Source/CTest/cmCTestSubmitCommand.h b/Source/CTest/cmCTestSubmitCommand.h index 6323d8c..7c3d6cd 100644 --- a/Source/CTest/cmCTestSubmitCommand.h +++ b/Source/CTest/cmCTestSubmitCommand.h @@ -38,7 +38,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestSubmitCommand* ni = new cmCTestSubmitCommand; ni->CTest = this->CTest; @@ -46,21 +46,21 @@ public: return ni; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_submit"; } + std::string GetName() const CM_OVERRIDE { return "ctest_submit"; } cmTypeMacro(cmCTestSubmitCommand, cmCTestHandlerCommand); protected: - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; - virtual bool CheckArgumentKeyword(std::string const& arg); - virtual bool CheckArgumentValue(std::string const& arg); + bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE; + bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE; enum { diff --git a/Source/CTest/cmCTestSubmitHandler.cxx b/Source/CTest/cmCTestSubmitHandler.cxx index 69f2ac5..67388ad 100644 --- a/Source/CTest/cmCTestSubmitHandler.cxx +++ b/Source/CTest/cmCTestSubmitHandler.cxx @@ -41,7 +41,7 @@ class cmCTestSubmitHandler::ResponseParser : public cmXMLParser { public: ResponseParser() { this->Status = STATUS_OK; } - ~ResponseParser() {} + ~ResponseParser() CM_OVERRIDE {} public: enum StatusType @@ -69,7 +69,7 @@ private: return val; } - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { this->CurrentValue.clear(); if (name == "cdash") { @@ -77,12 +77,12 @@ private: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { this->CurrentValue.insert(this->CurrentValue.end(), data, data + length); } - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "status") { std::string status = cmSystemTools::UpperCase(this->GetCurrentValue()); @@ -150,7 +150,7 @@ void cmCTestSubmitHandler::Initialize() this->HTTPProxyAuth = ""; this->FTPProxy = ""; this->FTPProxyType = 0; - this->LogFile = 0; + this->LogFile = CM_NULLPTR; this->Files.clear(); } @@ -308,7 +308,7 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, FILE* ftpfile; char error_buffer[1024]; struct curl_slist* headers = - ::curl_slist_append(NULL, "Content-Type: text/xml"); + ::curl_slist_append(CM_NULLPTR, "Content-Type: text/xml"); /* In windows, this will init the winsock stuff */ ::curl_global_init(CURL_GLOBAL_ALL); @@ -507,10 +507,10 @@ bool cmCTestSubmitHandler::SubmitUsingHTTP(const std::string& localprefix, // If curl failed for any reason, or checksum fails, wait and retry // if (res != CURLE_OK || this->HasErrors) { - std::string retryDelay = this->GetOption("RetryDelay") == NULL + std::string retryDelay = this->GetOption("RetryDelay") == CM_NULLPTR ? "" : this->GetOption("RetryDelay"); - std::string retryCount = this->GetOption("RetryCount") == NULL + std::string retryCount = this->GetOption("RetryCount") == CM_NULLPTR ? "" : this->GetOption("RetryCount"); @@ -776,7 +776,7 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command, argv.push_back(scp_command.c_str()); // Scp command argv.push_back(scp_command.c_str()); // Dummy string for file argv.push_back(scp_command.c_str()); // Dummy string for remote url - argv.push_back(0); + argv.push_back(CM_NULLPTR); cmsysProcess* cp = cmsysProcess_New(); cmsysProcess_SetOption(cp, cmsysProcess_Option_HideWindow, 1); @@ -807,12 +807,12 @@ bool cmCTestSubmitHandler::SubmitUsingSCP(const std::string& scp_command, char* data; int length; - while (cmsysProcess_WaitForData(cp, &data, &length, 0)) { + while (cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR)) { cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, cmCTestLogWrite(data, length), this->Quiet); } - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); int result = cmsysProcess_GetState(cp); diff --git a/Source/CTest/cmCTestSubmitHandler.h b/Source/CTest/cmCTestSubmitHandler.h index 87fa142..4cca6eb 100644 --- a/Source/CTest/cmCTestSubmitHandler.h +++ b/Source/CTest/cmCTestSubmitHandler.h @@ -26,14 +26,14 @@ public: cmTypeMacro(cmCTestSubmitHandler, cmCTestGenericHandler); cmCTestSubmitHandler(); - ~cmCTestSubmitHandler() { this->LogFile = 0; } + ~cmCTestSubmitHandler() CM_OVERRIDE { this->LogFile = CM_NULLPTR; } /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; - void Initialize(); + void Initialize() CM_OVERRIDE; /** Specify a set of parts (by name) to submit. */ void SelectParts(std::set<cmCTest::Part> const& parts); diff --git a/Source/CTest/cmCTestTestCommand.cxx b/Source/CTest/cmCTestTestCommand.cxx index 7b437c6..1d064db 100644 --- a/Source/CTest/cmCTestTestCommand.cxx +++ b/Source/CTest/cmCTestTestCommand.cxx @@ -27,7 +27,7 @@ cmCTestTestCommand::cmCTestTestCommand() this->Arguments[ctt_SCHEDULE_RANDOM] = "SCHEDULE_RANDOM"; this->Arguments[ctt_STOP_TIME] = "STOP_TIME"; this->Arguments[ctt_TEST_LOAD] = "TEST_LOAD"; - this->Arguments[ctt_LAST] = 0; + this->Arguments[ctt_LAST] = CM_NULLPTR; this->Last = ctt_LAST; } diff --git a/Source/CTest/cmCTestTestCommand.h b/Source/CTest/cmCTestTestCommand.h index 212213e..f652971 100644 --- a/Source/CTest/cmCTestTestCommand.h +++ b/Source/CTest/cmCTestTestCommand.h @@ -27,7 +27,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestTestCommand* ni = new cmCTestTestCommand; ni->CTest = this->CTest; @@ -38,13 +38,13 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_test"; } + std::string GetName() const CM_OVERRIDE { return "ctest_test"; } cmTypeMacro(cmCTestTestCommand, cmCTestHandlerCommand); protected: virtual cmCTestGenericHandler* InitializeActualHandler(); - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; enum { diff --git a/Source/CTest/cmCTestTestHandler.cxx b/Source/CTest/cmCTestTestHandler.cxx index c991a23..cd250fb 100644 --- a/Source/CTest/cmCTestTestHandler.cxx +++ b/Source/CTest/cmCTestTestHandler.cxx @@ -42,7 +42,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestSubdirCommand* c = new cmCTestSubdirCommand; c->TestHandler = this->TestHandler; @@ -53,13 +53,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus&) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "subdirs"; } + std::string GetName() const CM_OVERRIDE { return "subdirs"; } cmTypeMacro(cmCTestSubdirCommand, cmCommand); @@ -123,7 +123,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestAddSubdirectoryCommand* c = new cmCTestAddSubdirectoryCommand; c->TestHandler = this->TestHandler; @@ -134,13 +134,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus&) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_subdirectory"; } + std::string GetName() const CM_OVERRIDE { return "add_subdirectory"; } cmTypeMacro(cmCTestAddSubdirectoryCommand, cmCommand); @@ -197,7 +197,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestAddTestCommand* c = new cmCTestAddTestCommand; c->TestHandler = this->TestHandler; @@ -208,13 +208,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_test"; } + std::string GetName() const CM_OVERRIDE { return "add_test"; } cmTypeMacro(cmCTestAddTestCommand, cmCommand); @@ -237,7 +237,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestSetTestsPropertiesCommand* c = new cmCTestSetTestsPropertiesCommand; c->TestHandler = this->TestHandler; @@ -248,13 +248,13 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_tests_properties"; } + std::string GetName() const CM_OVERRIDE { return "set_tests_properties"; } cmTypeMacro(cmCTestSetTestsPropertiesCommand, cmCommand); @@ -336,7 +336,7 @@ cmCTestTestHandler::cmCTestTestHandler() this->MemCheck = false; - this->LogFile = 0; + this->LogFile = CM_NULLPTR; // regex to detect <DartMeasurement>...</DartMeasurement> this->DartStuff.compile("(<DartMeasurement.*/DartMeasurement[a-zA-Z]*>)"); @@ -550,7 +550,7 @@ int cmCTestTestHandler::ProcessHandler() cmCTestLog(this->CTest, ERROR_MESSAGE, "Cannot create " << (this->MemCheck ? "memory check" : "testing") << " XML file" << std::endl); - this->LogFile = 0; + this->LogFile = CM_NULLPTR; return 1; } cmXMLWriter xml(xmlfile); @@ -558,15 +558,15 @@ int cmCTestTestHandler::ProcessHandler() } if (!this->PostProcessHandler()) { - this->LogFile = 0; + this->LogFile = CM_NULLPTR; return -1; } if (!failed.empty()) { - this->LogFile = 0; + this->LogFile = CM_NULLPTR; return -1; } - this->LogFile = 0; + this->LogFile = CM_NULLPTR; return 0; } @@ -936,7 +936,7 @@ void cmCTestTestHandler::ProcessDirectory(std::vector<std::string>& passed, bool randomSchedule = this->CTest->GetScheduleType() == "Random"; if (randomSchedule) { - srand((unsigned)time(0)); + srand((unsigned)time(CM_NULLPTR)); } for (ListOfTests::iterator it = this->TestList.begin(); @@ -1154,7 +1154,8 @@ int cmCTestTestHandler::ExecuteCommands(std::vector<std::string>& vec) int retVal = 0; cmCTestOptionalLog(this->CTest, HANDLER_VERBOSE_OUTPUT, "Run command: " << *it << std::endl, this->Quiet); - if (!cmSystemTools::RunSingleCommand(it->c_str(), 0, 0, &retVal, 0, + if (!cmSystemTools::RunSingleCommand(it->c_str(), CM_NULLPTR, CM_NULLPTR, + &retVal, CM_NULLPTR, cmSystemTools::OUTPUT_MERGE /*this->Verbose*/) || retVal != 0) { @@ -1351,7 +1352,7 @@ void cmCTestTestHandler::GetListOfTests() cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); mf->AddDefinition("CTEST_CONFIGURATION_TYPE", this->CTest->GetConfigType().c_str()); diff --git a/Source/CTest/cmCTestTestHandler.h b/Source/CTest/cmCTestTestHandler.h index 4b74ce0..a085a82 100644 --- a/Source/CTest/cmCTestTestHandler.h +++ b/Source/CTest/cmCTestTestHandler.h @@ -36,7 +36,7 @@ public: /** * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; /** * When both -R and -I are used should te resulting test list be the @@ -54,7 +54,7 @@ public: /** * This method is called when reading CTest custom file */ - void PopulateCustomVectors(cmMakefile* mf); + void PopulateCustomVectors(cmMakefile* mf) CM_OVERRIDE; ///! Control the use of the regular expresisons, call these methods to turn /// them on @@ -90,7 +90,7 @@ public: */ bool SetTestsProperties(const std::vector<std::string>& args); - void Initialize(); + void Initialize() CM_OVERRIDE; // NOTE: This struct is Saved/Restored // in cmCTestTestHandler, if you add to this class diff --git a/Source/CTest/cmCTestUpdateCommand.cxx b/Source/CTest/cmCTestUpdateCommand.cxx index f1bae5d..bc06da6 100644 --- a/Source/CTest/cmCTestUpdateCommand.cxx +++ b/Source/CTest/cmCTestUpdateCommand.cxx @@ -83,12 +83,12 @@ cmCTestGenericHandler* cmCTestUpdateCommand::InitializeHandler() this->CTest->GetInitializedHandler("update"); if (!handler) { this->SetError("internal CTest error. Cannot instantiate update handler"); - return 0; + return CM_NULLPTR; } handler->SetCommand(this); if (source_dir.empty()) { this->SetError("source directory not specified. Please use SOURCE tag"); - return 0; + return CM_NULLPTR; } handler->SetOption("SourceDirectory", source_dir.c_str()); handler->SetQuiet(this->Quiet); diff --git a/Source/CTest/cmCTestUpdateCommand.h b/Source/CTest/cmCTestUpdateCommand.h index e807193..6b5bbab 100644 --- a/Source/CTest/cmCTestUpdateCommand.h +++ b/Source/CTest/cmCTestUpdateCommand.h @@ -27,7 +27,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestUpdateCommand* ni = new cmCTestUpdateCommand; ni->CTest = this->CTest; @@ -38,12 +38,12 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_update"; } + std::string GetName() const CM_OVERRIDE { return "ctest_update"; } cmTypeMacro(cmCTestUpdateCommand, cmCTestHandlerCommand); protected: - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; }; #endif diff --git a/Source/CTest/cmCTestUpdateHandler.cxx b/Source/CTest/cmCTestUpdateHandler.cxx index 4eaa16b..ac7eb05 100644 --- a/Source/CTest/cmCTestUpdateHandler.cxx +++ b/Source/CTest/cmCTestUpdateHandler.cxx @@ -30,7 +30,7 @@ #include "cmCTestSVN.h" #include "cmCTestVC.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> //#include <cmsys/RegularExpression.hxx> #include <cmsys/Process.h> @@ -159,7 +159,7 @@ int cmCTestUpdateHandler::ProcessHandler() , this->Quiet); // Create an object to interact with the VCS tool. - cmsys::auto_ptr<cmCTestVC> vc; + CM_AUTO_PTR<cmCTestVC> vc; switch (this->UpdateType) { case e_CVS: vc.reset(new cmCTestCVS(this->CTest, ofs)); @@ -334,7 +334,7 @@ bool cmCTestUpdateHandler::SelectVCS() // If no update command was specified, lookup one for this VCS tool. if (this->UpdateCommand.empty()) { - const char* key = 0; + const char* key = CM_NULLPTR; switch (this->UpdateType) { case e_CVS: key = "CVSCommand"; diff --git a/Source/CTest/cmCTestUpdateHandler.h b/Source/CTest/cmCTestUpdateHandler.h index d44e619..6733c8c 100644 --- a/Source/CTest/cmCTestUpdateHandler.h +++ b/Source/CTest/cmCTestUpdateHandler.h @@ -29,7 +29,7 @@ public: /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; cmCTestUpdateHandler(); @@ -48,7 +48,7 @@ public: /** * Initialize handler */ - virtual void Initialize(); + void Initialize() CM_OVERRIDE; private: // Some structures needed for update diff --git a/Source/CTest/cmCTestUploadCommand.cxx b/Source/CTest/cmCTestUploadCommand.cxx index c85db02..7393d21 100644 --- a/Source/CTest/cmCTestUploadCommand.cxx +++ b/Source/CTest/cmCTestUploadCommand.cxx @@ -21,7 +21,7 @@ cmCTestGenericHandler* cmCTestUploadCommand::InitializeHandler() this->CTest->GetInitializedHandler("upload"); if (!handler) { this->SetError("internal CTest error. Cannot instantiate upload handler"); - return 0; + return CM_NULLPTR; } static_cast<cmCTestUploadHandler*>(handler)->SetFiles(this->Files); diff --git a/Source/CTest/cmCTestUploadCommand.h b/Source/CTest/cmCTestUploadCommand.h index 551be2b..923995d 100644 --- a/Source/CTest/cmCTestUploadCommand.h +++ b/Source/CTest/cmCTestUploadCommand.h @@ -30,7 +30,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmCTestUploadCommand* ni = new cmCTestUploadCommand; ni->CTest = this->CTest; @@ -41,15 +41,15 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "ctest_upload"; } + std::string GetName() const CM_OVERRIDE { return "ctest_upload"; } cmTypeMacro(cmCTestUploadCommand, cmCTestHandlerCommand); protected: - cmCTestGenericHandler* InitializeHandler(); + cmCTestGenericHandler* InitializeHandler() CM_OVERRIDE; - virtual bool CheckArgumentKeyword(std::string const& arg); - virtual bool CheckArgumentValue(std::string const& arg); + bool CheckArgumentKeyword(std::string const& arg) CM_OVERRIDE; + bool CheckArgumentValue(std::string const& arg) CM_OVERRIDE; enum { diff --git a/Source/CTest/cmCTestUploadHandler.h b/Source/CTest/cmCTestUploadHandler.h index 23ed35a..8b824d6 100644 --- a/Source/CTest/cmCTestUploadHandler.h +++ b/Source/CTest/cmCTestUploadHandler.h @@ -26,14 +26,14 @@ public: cmTypeMacro(cmCTestUploadHandler, cmCTestGenericHandler); cmCTestUploadHandler(); - ~cmCTestUploadHandler() {} + ~cmCTestUploadHandler() CM_OVERRIDE {} /* * The main entry point for this class */ - int ProcessHandler(); + int ProcessHandler() CM_OVERRIDE; - void Initialize(); + void Initialize() CM_OVERRIDE; /** Specify a set of files to submit. */ void SetFiles(cmCTest::SetOfStrings const& files); diff --git a/Source/CTest/cmCTestVC.cxx b/Source/CTest/cmCTestVC.cxx index e9934e5..3376588 100644 --- a/Source/CTest/cmCTestVC.cxx +++ b/Source/CTest/cmCTestVC.cxx @@ -65,7 +65,7 @@ bool cmCTestVC::InitialCheckout(const char* command) ai != args.end(); ++ai) { vc_co.push_back(ai->c_str()); } - vc_co.push_back(0); + vc_co.push_back(CM_NULLPTR); // Run the initial checkout command and log its output. this->Log << "--- Begin Initial Checkout ---\n"; diff --git a/Source/CTest/cmCTestVC.h b/Source/CTest/cmCTestVC.h index 4ae38eb..eb85a236 100644 --- a/Source/CTest/cmCTestVC.h +++ b/Source/CTest/cmCTestVC.h @@ -104,8 +104,8 @@ protected: Revision const* PriorRev; File() : Status(PathUpdated) - , Rev(0) - , PriorRev(0) + , Rev(CM_NULLPTR) + , PriorRev(CM_NULLPTR) { } File(PathStatus status, Revision const* rev, Revision const* priorRev) @@ -121,11 +121,11 @@ protected: /** Run a command line and send output to given parsers. */ bool RunChild(char const* const* cmd, OutputParser* out, OutputParser* err, - const char* workDir = 0); + const char* workDir = CM_NULLPTR); /** Run VC update command line and send output to given parsers. */ bool RunUpdateCommand(char const* const* cmd, OutputParser* out, - OutputParser* err = 0); + OutputParser* err = CM_NULLPTR); /** Write xml element for one file. */ void WriteXMLEntry(cmXMLWriter& xml, std::string const& path, diff --git a/Source/CTest/cmParseCacheCoverage.h b/Source/CTest/cmParseCacheCoverage.h index bd331d0..65b1d10 100644 --- a/Source/CTest/cmParseCacheCoverage.h +++ b/Source/CTest/cmParseCacheCoverage.h @@ -28,7 +28,7 @@ public: protected: // implement virtual from parent - bool LoadCoverageData(const char* dir); + bool LoadCoverageData(const char* dir) CM_OVERRIDE; // remove files with no coverage void RemoveUnCoveredFiles(); // Read a single mcov file diff --git a/Source/CTest/cmParseCoberturaCoverage.cxx b/Source/CTest/cmParseCoberturaCoverage.cxx index 3bdae17..1a3fe3c 100644 --- a/Source/CTest/cmParseCoberturaCoverage.cxx +++ b/Source/CTest/cmParseCoberturaCoverage.cxx @@ -20,10 +20,10 @@ public: this->CurFileName = ""; } - virtual ~XMLParser() {} + ~XMLParser() CM_OVERRIDE {} protected: - virtual void EndElement(const std::string& name) + void EndElement(const std::string& name) CM_OVERRIDE { if (name == "source") { this->InSource = false; @@ -34,7 +34,7 @@ protected: } } - virtual void CharacterDataHandler(const char* data, int length) + void CharacterDataHandler(const char* data, int length) CM_OVERRIDE { std::string tmp; tmp.insert(0, data, length); @@ -46,7 +46,7 @@ protected: } } - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { std::string FoundSource; std::string finalpath = ""; diff --git a/Source/CTest/cmParseGTMCoverage.h b/Source/CTest/cmParseGTMCoverage.h index bc2f2ec..4188689 100644 --- a/Source/CTest/cmParseGTMCoverage.h +++ b/Source/CTest/cmParseGTMCoverage.h @@ -28,7 +28,7 @@ public: protected: // implement virtual from parent - bool LoadCoverageData(const char* dir); + bool LoadCoverageData(const char* dir) CM_OVERRIDE; // Read a single mcov file bool ReadMCovFile(const char* f); // find out what line in a mumps file (filepath) the given entry point diff --git a/Source/CTest/cmParseJacocoCoverage.cxx b/Source/CTest/cmParseJacocoCoverage.cxx index e456f39..9325812 100644 --- a/Source/CTest/cmParseJacocoCoverage.cxx +++ b/Source/CTest/cmParseJacocoCoverage.cxx @@ -20,12 +20,12 @@ public: this->PackageName = ""; } - virtual ~XMLParser() {} + ~XMLParser() CM_OVERRIDE {} protected: - virtual void EndElement(const std::string&) {} + void EndElement(const std::string&) CM_OVERRIDE {} - virtual void StartElement(const std::string& name, const char** atts) + void StartElement(const std::string& name, const char** atts) CM_OVERRIDE { if (name == "package") { this->PackageName = atts[1]; diff --git a/Source/CTest/cmParseMumpsCoverage.cxx b/Source/CTest/cmParseMumpsCoverage.cxx index e5dd74a..d786d79 100644 --- a/Source/CTest/cmParseMumpsCoverage.cxx +++ b/Source/CTest/cmParseMumpsCoverage.cxx @@ -130,8 +130,8 @@ bool cmParseMumpsCoverage::FindMumpsFile(std::string const& routine, return true; } else { // try some alternate names - const char* tryname[] = { "GUX", "GTM", "ONT", 0 }; - for (int k = 0; tryname[k] != 0; k++) { + const char* tryname[] = { "GUX", "GTM", "ONT", CM_NULLPTR }; + for (int k = 0; tryname[k] != CM_NULLPTR; k++) { std::string routine2 = routine + tryname[k]; i = this->RoutineToDirectory.find(routine2); if (i != this->RoutineToDirectory.end()) { diff --git a/Source/CTest/cmProcess.cxx b/Source/CTest/cmProcess.cxx index db5151c..92fe642 100644 --- a/Source/CTest/cmProcess.cxx +++ b/Source/CTest/cmProcess.cxx @@ -16,7 +16,7 @@ cmProcess::cmProcess() { - this->Process = 0; + this->Process = CM_NULLPTR; this->Timeout = 0; this->TotalTime = 0; this->ExitValue = 0; @@ -52,7 +52,7 @@ bool cmProcess::StartProcess() i != this->Arguments.end(); ++i) { this->ProcessArgs.push_back(i->c_str()); } - this->ProcessArgs.push_back(0); // null terminate the list + this->ProcessArgs.push_back(CM_NULLPTR); // null terminate the list this->Process = cmsysProcess_New(); cmsysProcess_SetCommand(this->Process, &*this->ProcessArgs.begin()); if (!this->WorkingDirectory.empty()) { diff --git a/Source/Checks/cm_cxx11_unordered_map.cmake b/Source/Checks/cm_cxx11_unordered_map.cmake deleted file mode 100644 index 80fe391..0000000 --- a/Source/Checks/cm_cxx11_unordered_map.cmake +++ /dev/null @@ -1,25 +0,0 @@ - -if(CMAKE_CXX_STANDARD AND NOT DEFINED CMake_HAVE_CXX11_UNORDERED_MAP) - message(STATUS "Checking if compiler supports C++11 unordered_map") - try_compile(CMake_HAVE_CXX11_UNORDERED_MAP - ${CMAKE_CURRENT_BINARY_DIR} - ${CMAKE_CURRENT_LIST_DIR}/cm_cxx11_unordered_map.cpp - CMAKE_FLAGS -DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} - OUTPUT_VARIABLE OUTPUT - ) - if(CMake_HAVE_CXX11_UNORDERED_MAP) - message(STATUS "Checking if compiler supports C++11 unordered_map - yes") - file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log - "Determining if compiler supports C++11 unordered_map passed with the following output:\n" - "${OUTPUT}\n" - "\n" - ) - else() - message(STATUS "Checking if compiler supports C++11 unordered_map - no") - file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log - "Determining if compiler supports C++11 unordered_map failed with the following output:\n" - "${OUTPUT}\n" - "\n" - ) - endif() -endif() diff --git a/Source/Checks/cm_cxx_features.cmake b/Source/Checks/cm_cxx_features.cmake new file mode 100644 index 0000000..6fde7b6 --- /dev/null +++ b/Source/Checks/cm_cxx_features.cmake @@ -0,0 +1,39 @@ + +function(cm_check_cxx_feature name) + string(TOUPPER ${name} FEATURE) + if(NOT DEFINED CMake_HAVE_CXX_${FEATURE}) + message(STATUS "Checking if compiler supports C++ ${name}") + try_compile(CMake_HAVE_CXX_${FEATURE} + ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_LIST_DIR}/cm_cxx_${name}.cxx + CMAKE_FLAGS -DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD} + OUTPUT_VARIABLE OUTPUT + ) + # If using the feature causes warnings, treat it as broken/unavailable. + if(OUTPUT MATCHES "warning") + set(CMake_HAVE_CXX_${FEATURE} OFF CACHE INTERNAL "TRY_COMPILE" FORCE) + endif() + if(CMake_HAVE_CXX_${FEATURE}) + message(STATUS "Checking if compiler supports C++ ${name} - yes") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log + "Determining if compiler supports C++ ${name} passed with the following output:\n" + "${OUTPUT}\n" + "\n" + ) + else() + message(STATUS "Checking if compiler supports C++ ${name} - no") + file(APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log + "Determining if compiler supports C++ ${name} failed with the following output:\n" + "${OUTPUT}\n" + "\n" + ) + endif() + endif() +endfunction() + +if(CMAKE_CXX_STANDARD) + cm_check_cxx_feature(nullptr) + cm_check_cxx_feature(override) + cm_check_cxx_feature(unordered_map) + cm_check_cxx_feature(unordered_set) +endif() diff --git a/Source/Checks/cm_cxx_nullptr.cxx b/Source/Checks/cm_cxx_nullptr.cxx new file mode 100644 index 0000000..500684a --- /dev/null +++ b/Source/Checks/cm_cxx_nullptr.cxx @@ -0,0 +1,14 @@ +int test(int) +{ + return -1; +} + +int test(int*) +{ + return 0; +} + +int main() +{ + return test(nullptr); +} diff --git a/Source/Checks/cm_cxx_override.cxx b/Source/Checks/cm_cxx_override.cxx new file mode 100644 index 0000000..5a33fbb --- /dev/null +++ b/Source/Checks/cm_cxx_override.cxx @@ -0,0 +1,24 @@ +struct Foo +{ + Foo() {} + virtual ~Foo() {} + virtual int test() const = 0; +}; + +struct Bar : Foo +{ + Bar() {} + ~Bar() override {} + int test() const override { return 0; } +}; + +int test(Foo const& foo) +{ + return foo.test(); +} + +int main() +{ + Bar const bar; + return test(bar); +} diff --git a/Source/Checks/cm_cxx11_unordered_map.cpp b/Source/Checks/cm_cxx_unordered_map.cxx index be3de25..be3de25 100644 --- a/Source/Checks/cm_cxx11_unordered_map.cpp +++ b/Source/Checks/cm_cxx_unordered_map.cxx diff --git a/Source/Checks/cm_cxx_unordered_set.cxx b/Source/Checks/cm_cxx_unordered_set.cxx new file mode 100644 index 0000000..de4bb77 --- /dev/null +++ b/Source/Checks/cm_cxx_unordered_set.cxx @@ -0,0 +1,7 @@ +#include <unordered_set> +int main() +{ + std::unordered_set<int> set; + set.insert(0); + return 0; +} diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx index be8751c..606c954 100644 --- a/Source/CursesDialog/ccmake.cxx +++ b/Source/CursesDialog/ccmake.cxx @@ -24,29 +24,30 @@ #include <form.h> static const char* cmDocumentationName[][2] = { - { 0, " ccmake - Curses Interface for CMake." }, - { 0, 0 } + { CM_NULLPTR, " ccmake - Curses Interface for CMake." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationUsage[][2] = { - { 0, " ccmake <path-to-source>\n" - " ccmake <path-to-existing-build>" }, - { 0, "Specify a source directory to (re-)generate a build system for " - "it in the current working directory. Specify an existing build " - "directory to re-generate its build system." }, - { 0, 0 } + { CM_NULLPTR, " ccmake <path-to-source>\n" + " ccmake <path-to-existing-build>" }, + { CM_NULLPTR, + "Specify a source directory to (re-)generate a build system for " + "it in the current working directory. Specify an existing build " + "directory to re-generate its build system." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationUsageNote[][2] = { - { 0, "Run 'ccmake --help' for more information." }, - { 0, 0 } + { CM_NULLPTR, "Run 'ccmake --help' for more information." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationOptions[] [2] = { CMAKE_STANDARD_OPTIONS_TABLE, - { 0, 0 } }; + { CM_NULLPTR, CM_NULLPTR } }; -cmCursesForm* cmCursesForm::CurrentForm = 0; +cmCursesForm* cmCursesForm::CurrentForm = CM_NULLPTR; extern "C" { @@ -176,7 +177,7 @@ int main(int argc, char const* const* argv) touchwin(stdscr); endwin(); delete cmCursesForm::CurrentForm; - cmCursesForm::CurrentForm = 0; + cmCursesForm::CurrentForm = CM_NULLPTR; std::cout << std::endl << std::endl; diff --git a/Source/CursesDialog/cmCursesBoolWidget.h b/Source/CursesDialog/cmCursesBoolWidget.h index 49be45a..d2899ee 100644 --- a/Source/CursesDialog/cmCursesBoolWidget.h +++ b/Source/CursesDialog/cmCursesBoolWidget.h @@ -25,7 +25,7 @@ public: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was // handled. - virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w); + bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; // Description: // Set/Get the value (on/off). diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx index bdfc8e9..ea12756 100644 --- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx +++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx @@ -32,7 +32,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite( { this->Label = new cmCursesLabelWidget(this->LabelWidth, 1, 1, 1, key); this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " "); - this->Entry = 0; + this->Entry = CM_NULLPTR; this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1); } @@ -50,7 +50,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite( this->IsNewLabel = new cmCursesLabelWidget(1, 1, 1, 1, " "); } - this->Entry = 0; + this->Entry = CM_NULLPTR; const char* value = cm->GetState()->GetCacheEntryValue(key); assert(value); switch (cm->GetState()->GetCacheEntryType(key)) { @@ -111,6 +111,6 @@ const char* cmCursesCacheEntryComposite::GetValue() if (this->Label) { return this->Label->GetValue(); } else { - return 0; + return CM_NULLPTR; } } diff --git a/Source/CursesDialog/cmCursesDummyWidget.h b/Source/CursesDialog/cmCursesDummyWidget.h index 9a3df29..e6ca91e 100644 --- a/Source/CursesDialog/cmCursesDummyWidget.h +++ b/Source/CursesDialog/cmCursesDummyWidget.h @@ -25,7 +25,7 @@ public: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was // handled. - virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w); + bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; protected: cmCursesDummyWidget(const cmCursesDummyWidget& from); diff --git a/Source/CursesDialog/cmCursesForm.cxx b/Source/CursesDialog/cmCursesForm.cxx index aa4710f..b3320c9 100644 --- a/Source/CursesDialog/cmCursesForm.cxx +++ b/Source/CursesDialog/cmCursesForm.cxx @@ -16,7 +16,7 @@ bool cmCursesForm::Debug = false; cmCursesForm::cmCursesForm() { - this->Form = 0; + this->Form = CM_NULLPTR; } cmCursesForm::~cmCursesForm() @@ -24,7 +24,7 @@ cmCursesForm::~cmCursesForm() if (this->Form) { unpost_form(this->Form); free_form(this->Form); - this->Form = 0; + this->Form = CM_NULLPTR; } } diff --git a/Source/CursesDialog/cmCursesLabelWidget.h b/Source/CursesDialog/cmCursesLabelWidget.h index c31a58c..ff645af 100644 --- a/Source/CursesDialog/cmCursesLabelWidget.h +++ b/Source/CursesDialog/cmCursesLabelWidget.h @@ -21,13 +21,13 @@ class cmCursesLabelWidget : public cmCursesWidget public: cmCursesLabelWidget(int width, int height, int left, int top, const std::string& name); - virtual ~cmCursesLabelWidget(); + ~cmCursesLabelWidget() CM_OVERRIDE; // Description: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was // handled - virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w); + bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; protected: cmCursesLabelWidget(const cmCursesLabelWidget& from); diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx index d03d330..48cc42c 100644 --- a/Source/CursesDialog/cmCursesLongMessageForm.cxx +++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx @@ -32,8 +32,8 @@ cmCursesLongMessageForm::cmCursesLongMessageForm( this->Messages += "\n\n"; } this->Title = title; - this->Fields[0] = 0; - this->Fields[1] = 0; + this->Fields[0] = CM_NULLPTR; + this->Fields[1] = CM_NULLPTR; } cmCursesLongMessageForm::~cmCursesLongMessageForm() @@ -110,7 +110,7 @@ void cmCursesLongMessageForm::Render(int, int, int, int) if (this->Form) { unpost_form(this->Form); free_form(this->Form); - this->Form = 0; + this->Form = CM_NULLPTR; } const char* msg = this->Messages.c_str(); @@ -119,7 +119,7 @@ void cmCursesLongMessageForm::Render(int, int, int, int) if (this->Fields[0]) { free_field(this->Fields[0]); - this->Fields[0] = 0; + this->Fields[0] = CM_NULLPTR; } this->Fields[0] = new_field(y - 6, x - 2, 1, 1, 0, 0); diff --git a/Source/CursesDialog/cmCursesLongMessageForm.h b/Source/CursesDialog/cmCursesLongMessageForm.h index 73ccfc4..a12ed2f 100644 --- a/Source/CursesDialog/cmCursesLongMessageForm.h +++ b/Source/CursesDialog/cmCursesLongMessageForm.h @@ -23,16 +23,16 @@ class cmCursesLongMessageForm : public cmCursesForm public: cmCursesLongMessageForm(std::vector<std::string> const& messages, const char* title); - virtual ~cmCursesLongMessageForm(); + ~cmCursesLongMessageForm() CM_OVERRIDE; // Description: // Handle user input. - virtual void HandleInput(); + void HandleInput() CM_OVERRIDE; // Description: // Display form. Use a window of size width x height, starting // at top, left. - virtual void Render(int left, int top, int width, int height); + void Render(int left, int top, int width, int height) CM_OVERRIDE; // Description: // This method should normally called only by the form. @@ -42,7 +42,7 @@ public: // Description: // This method should normally called only by the form. // The only exception is during a resize. - virtual void UpdateStatusBar(); + void UpdateStatusBar() CM_OVERRIDE; protected: cmCursesLongMessageForm(const cmCursesLongMessageForm& from); diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx index b740eb0..9ae38d6 100644 --- a/Source/CursesDialog/cmCursesMainForm.cxx +++ b/Source/CursesDialog/cmCursesMainForm.cxx @@ -36,8 +36,8 @@ cmCursesMainForm::cmCursesMainForm(std::vector<std::string> const& args, , InitialWidth(initWidth) { this->NumberOfPages = 0; - this->Fields = 0; - this->Entries = 0; + this->Fields = CM_NULLPTR; + this->Entries = CM_NULLPTR; this->AdvancedMode = false; this->NumberOfVisibleEntries = 0; this->OkToGenerate = false; @@ -64,7 +64,7 @@ cmCursesMainForm::~cmCursesMainForm() if (this->Form) { unpost_form(this->Form); free_form(this->Form); - this->Form = 0; + this->Form = CM_NULLPTR; } delete[] this->Fields; @@ -75,7 +75,7 @@ cmCursesMainForm::~cmCursesMainForm() delete this->Entries; if (this->CMakeInstance) { delete this->CMakeInstance; - this->CMakeInstance = 0; + this->CMakeInstance = CM_NULLPTR; } } @@ -185,7 +185,7 @@ void cmCursesMainForm::RePost() if (this->Form) { unpost_form(this->Form); free_form(this->Form); - this->Form = 0; + this->Form = CM_NULLPTR; } delete[] this->Fields; if (this->AdvancedMode) { @@ -215,7 +215,7 @@ void cmCursesMainForm::RePost() this->Fields = new FIELD*[3 * this->NumberOfVisibleEntries + 1]; size_t cc; for (cc = 0; cc < 3 * this->NumberOfVisibleEntries + 1; cc++) { - this->Fields[cc] = 0; + this->Fields[cc] = CM_NULLPTR; } // Assign fields @@ -244,7 +244,7 @@ void cmCursesMainForm::RePost() this->NumberOfVisibleEntries = 1; } // Has to be null terminated. - this->Fields[3 * this->NumberOfVisibleEntries] = 0; + this->Fields[3 * this->NumberOfVisibleEntries] = CM_NULLPTR; } void cmCursesMainForm::Render(int left, int top, int width, int height) @@ -263,7 +263,7 @@ void cmCursesMainForm::Render(int left, int top, int width, int height) // Delete the previous form unpost_form(this->Form); free_form(this->Form); - this->Form = 0; + this->Form = CM_NULLPTR; } // Wrong window size @@ -345,7 +345,7 @@ void cmCursesMainForm::PrintKeys(int process /* = 0 */) } // Give the current widget (if it exists), a chance to print keys - cmCursesWidget* cw = 0; + cmCursesWidget* cw = CM_NULLPTR; if (this->Form) { FIELD* currentField = current_field(this->Form); cw = reinterpret_cast<cmCursesWidget*>(field_userptr(currentField)); @@ -434,7 +434,7 @@ void cmCursesMainForm::UpdateStatusBar(const char* message) // Get the key of the current entry FIELD* cur = current_field(this->Form); int findex = field_index(cur); - cmCursesWidget* lbl = 0; + cmCursesWidget* lbl = CM_NULLPTR; if (findex >= 0) { lbl = reinterpret_cast<cmCursesWidget*>( field_userptr(this->Fields[findex - 2])); @@ -566,7 +566,7 @@ int cmCursesMainForm::Configure(int noconfigure) this->FillCacheManagerFromUI(); this->CMakeInstance->SaveCache( this->CMakeInstance->GetHomeOutputDirectory()); - this->LoadCache(0); + this->LoadCache(CM_NULLPTR); // Get rid of previous errors this->Errors = std::vector<std::string>(); @@ -583,7 +583,7 @@ int cmCursesMainForm::Configure(int noconfigure) } else { retVal = this->CMakeInstance->Configure(); } - this->CMakeInstance->SetProgressCallback(0, 0); + this->CMakeInstance->SetProgressCallback(CM_NULLPTR, CM_NULLPTR); keypad(stdscr, TRUE); /* Use key symbols as KEY_DOWN*/ @@ -638,7 +638,7 @@ int cmCursesMainForm::Generate() // run the generate process int retVal = this->CMakeInstance->Generate(); - this->CMakeInstance->SetProgressCallback(0, 0); + this->CMakeInstance->SetProgressCallback(CM_NULLPTR, CM_NULLPTR); keypad(stdscr, TRUE); /* Use key symbols as KEY_DOWN*/ @@ -888,7 +888,7 @@ void cmCursesMainForm::HandleInput() cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>( field_userptr(this->Fields[findex - 2])); const char* curField = lbl->GetValue(); - const char* helpString = 0; + const char* helpString = CM_NULLPTR; const char* existingValue = this->CMakeInstance->GetState()->GetCacheEntryValue(curField); @@ -973,7 +973,7 @@ void cmCursesMainForm::HandleInput() // (findex always corresponds to the value field) FIELD* nextCur; if (findex == 2) { - nextCur = 0; + nextCur = CM_NULLPTR; } else if (findex == 3 * this->NumberOfVisibleEntries - 1) { nextCur = this->Fields[findex - 5]; } else { @@ -1003,7 +1003,7 @@ void cmCursesMainForm::HandleInput() if (nextCur) { // make the next or prev. current field after deletion - nextCur = 0; + nextCur = CM_NULLPTR; std::vector<cmCursesCacheEntryComposite*>::iterator it; for (it = this->Entries->begin(); it != this->Entries->end(); ++it) { @@ -1052,7 +1052,7 @@ void cmCursesMainForm::JumpToCacheEntry(const char* astr) int findex = start_index; for (;;) { if (!str.empty()) { - cmCursesWidget* lbl = 0; + cmCursesWidget* lbl = CM_NULLPTR; if (findex >= 0) { lbl = reinterpret_cast<cmCursesWidget*>( field_userptr(this->Fields[findex - 2])); diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h index 9aa0f67..d17ee33 100644 --- a/Source/CursesDialog/cmCursesMainForm.h +++ b/Source/CursesDialog/cmCursesMainForm.h @@ -30,7 +30,7 @@ class cmCursesMainForm : public cmCursesForm { public: cmCursesMainForm(std::vector<std::string> const& args, int initwidth); - virtual ~cmCursesMainForm(); + ~cmCursesMainForm() CM_OVERRIDE; /** * Set the widgets which represent the cache entries. @@ -40,13 +40,13 @@ public: /** * Handle user input. */ - virtual void HandleInput(); + void HandleInput() CM_OVERRIDE; /** * Display form. Use a window of size width x height, starting * at top, left. */ - virtual void Render(int left, int top, int width, int height); + void Render(int left, int top, int width, int height) CM_OVERRIDE; /** * Returns true if an entry with the given key is in the @@ -67,7 +67,7 @@ public: * exception is during a resize. The optional argument specifies the * string to be displayed in the status bar. */ - virtual void UpdateStatusBar() { this->UpdateStatusBar(0); } + void UpdateStatusBar() CM_OVERRIDE { this->UpdateStatusBar(CM_NULLPTR); } virtual void UpdateStatusBar(const char* message); /** @@ -83,7 +83,7 @@ public: * During a CMake run, an error handle should add errors * to be displayed afterwards. */ - virtual void AddError(const char* message, const char* title); + void AddError(const char* message, const char* title) CM_OVERRIDE; /** * Used to do a configure. If argument is specified, it does only the check diff --git a/Source/CursesDialog/cmCursesOptionsWidget.h b/Source/CursesDialog/cmCursesOptionsWidget.h index a17f2d5..f88b6bc 100644 --- a/Source/CursesDialog/cmCursesOptionsWidget.h +++ b/Source/CursesDialog/cmCursesOptionsWidget.h @@ -25,7 +25,7 @@ public: // Handle user input. Called by the container of this widget // when this widget has focus. Returns true if the input was // handled. - virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w); + bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; void SetOption(const std::string&); void AddOption(std::string const&); void NextOption(); diff --git a/Source/CursesDialog/cmCursesPathWidget.h b/Source/CursesDialog/cmCursesPathWidget.h index 18d298a..cd26df6 100644 --- a/Source/CursesDialog/cmCursesPathWidget.h +++ b/Source/CursesDialog/cmCursesPathWidget.h @@ -23,9 +23,9 @@ public: * This method is called when different keys are pressed. The * subclass can have a special implementation handler for this. */ - virtual void OnTab(cmCursesMainForm* fm, WINDOW* w); - virtual void OnReturn(cmCursesMainForm* fm, WINDOW* w); - virtual void OnType(int& key, cmCursesMainForm* fm, WINDOW* w); + void OnTab(cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; + void OnReturn(cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; + void OnType(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; protected: cmCursesPathWidget(const cmCursesPathWidget& from); diff --git a/Source/CursesDialog/cmCursesStringWidget.cxx b/Source/CursesDialog/cmCursesStringWidget.cxx index 3707d0d..6eb5310 100644 --- a/Source/CursesDialog/cmCursesStringWidget.cxx +++ b/Source/CursesDialog/cmCursesStringWidget.cxx @@ -72,7 +72,7 @@ bool cmCursesStringWidget::HandleInput(int& key, cmCursesMainForm* fm, return false; } - this->OriginalString = 0; + this->OriginalString = CM_NULLPTR; this->Done = false; char debugMessage[128]; diff --git a/Source/CursesDialog/cmCursesStringWidget.h b/Source/CursesDialog/cmCursesStringWidget.h index fc1b2ba..c8ca482 100644 --- a/Source/CursesDialog/cmCursesStringWidget.h +++ b/Source/CursesDialog/cmCursesStringWidget.h @@ -32,14 +32,14 @@ public: * when this widget has focus. Returns true if the input was * handled. */ - virtual bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w); + bool HandleInput(int& key, cmCursesMainForm* fm, WINDOW* w) CM_OVERRIDE; /** * Set/Get the string. */ void SetString(const std::string& value); const char* GetString(); - virtual const char* GetValue(); + const char* GetValue() CM_OVERRIDE; /** * Set/Get InEdit flag. Can be used to tell the widget to leave @@ -61,7 +61,7 @@ public: * in the toolbar and return true. Otherwise, return false * and the parent widget will print. */ - virtual bool PrintKeys(); + bool PrintKeys() CM_OVERRIDE; protected: cmCursesStringWidget(const cmCursesStringWidget& from); diff --git a/Source/CursesDialog/cmCursesWidget.cxx b/Source/CursesDialog/cmCursesWidget.cxx index 100ed1d..49f2795 100644 --- a/Source/CursesDialog/cmCursesWidget.cxx +++ b/Source/CursesDialog/cmCursesWidget.cxx @@ -23,7 +23,7 @@ cmCursesWidget::~cmCursesWidget() { if (this->Field) { free_field(this->Field); - this->Field = 0; + this->Field = CM_NULLPTR; } } diff --git a/Source/QtDialog/CMakeLists.txt b/Source/QtDialog/CMakeLists.txt index 68c65ac..80c0dc0 100644 --- a/Source/QtDialog/CMakeLists.txt +++ b/Source/QtDialog/CMakeLists.txt @@ -36,6 +36,12 @@ if (Qt5Widgets_FOUND) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${Qt5Widgets_EXECUTABLE_COMPILE_FLAGS}") + if(CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES) + list(APPEND CMake_QT_LIBRARIES ${CMake_QT_STATIC_QXcbIntegrationPlugin_LIBRARIES}) + set_property(SOURCE CMakeSetup.cxx + PROPERTY COMPILE_DEFINITIONS USE_QXcbIntegrationPlugin) + endif() + # We need to install platform plugin and add qt.conf for Qt5 on Mac and Windows. # FIXME: This should be part of Qt5 CMake scripts, but unfortunatelly # Qt5 support is missing there. diff --git a/Source/QtDialog/CMakeSetup.cxx b/Source/QtDialog/CMakeSetup.cxx index c849d52..ee3389c 100644 --- a/Source/QtDialog/CMakeSetup.cxx +++ b/Source/QtDialog/CMakeSetup.cxx @@ -22,6 +22,7 @@ #include <QString> #include <QTextCodec> #include <QTranslator> +#include <QtPlugin> #include <cmsys/CommandLineArguments.hxx> #include <cmsys/Encoding.hxx> #include <cmsys/SystemTools.hxx> @@ -44,6 +45,10 @@ static int cmOSXInstall(std::string dir); static void cmAddPluginPath(); #endif +#if defined(USE_QXcbIntegrationPlugin) +Q_IMPORT_PLUGIN(QXcbIntegrationPlugin); +#endif + int main(int argc, char** argv) { cmsys::Encoding::CommandLineArguments encoding_args = diff --git a/Source/cmAddCompileOptionsCommand.h b/Source/cmAddCompileOptionsCommand.h index 5c073c8..dba1acd 100644 --- a/Source/cmAddCompileOptionsCommand.h +++ b/Source/cmAddCompileOptionsCommand.h @@ -20,19 +20,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddCompileOptionsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddCompileOptionsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_compile_options"; } + std::string GetName() const CM_OVERRIDE { return "add_compile_options"; } cmTypeMacro(cmAddCompileOptionsCommand, cmCommand); }; diff --git a/Source/cmAddCustomCommandCommand.cxx b/Source/cmAddCustomCommandCommand.cxx index d8fd1d8..400be77 100644 --- a/Source/cmAddCustomCommandCommand.cxx +++ b/Source/cmAddCustomCommandCommand.cxx @@ -30,7 +30,7 @@ bool cmAddCustomCommandCommand::InitialPass( std::string source, target, main_dependency, working; std::string comment_buffer; - const char* comment = 0; + const char* comment = CM_NULLPTR; std::vector<std::string> depends, outputs, output, byproducts; bool verbatim = false; bool append = false; diff --git a/Source/cmAddCustomCommandCommand.h b/Source/cmAddCustomCommandCommand.h index ccbd50c..1164d46 100644 --- a/Source/cmAddCustomCommandCommand.h +++ b/Source/cmAddCustomCommandCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddCustomCommandCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddCustomCommandCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_custom_command"; } + std::string GetName() const CM_OVERRIDE { return "add_custom_command"; } cmTypeMacro(cmAddCustomCommandCommand, cmCommand); diff --git a/Source/cmAddCustomTargetCommand.cxx b/Source/cmAddCustomTargetCommand.cxx index ac08cb2..9dc7c59 100644 --- a/Source/cmAddCustomTargetCommand.cxx +++ b/Source/cmAddCustomTargetCommand.cxx @@ -47,7 +47,7 @@ bool cmAddCustomTargetCommand::InitialPass( bool verbatim = false; bool uses_terminal = false; std::string comment_buffer; - const char* comment = 0; + const char* comment = CM_NULLPTR; std::vector<std::string> sources; // Keep track of parser state. diff --git a/Source/cmAddCustomTargetCommand.h b/Source/cmAddCustomTargetCommand.h index 9c376c0..120d4d4 100644 --- a/Source/cmAddCustomTargetCommand.h +++ b/Source/cmAddCustomTargetCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddCustomTargetCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddCustomTargetCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_custom_target"; } + std::string GetName() const CM_OVERRIDE { return "add_custom_target"; } cmTypeMacro(cmAddCustomTargetCommand, cmCommand); }; diff --git a/Source/cmAddDefinitionsCommand.h b/Source/cmAddDefinitionsCommand.h index 959ed64..b30001c 100644 --- a/Source/cmAddDefinitionsCommand.h +++ b/Source/cmAddDefinitionsCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddDefinitionsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddDefinitionsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_definitions"; } + std::string GetName() const CM_OVERRIDE { return "add_definitions"; } cmTypeMacro(cmAddDefinitionsCommand, cmCommand); }; diff --git a/Source/cmAddDependenciesCommand.h b/Source/cmAddDependenciesCommand.h index 202d072..c059ff2 100644 --- a/Source/cmAddDependenciesCommand.h +++ b/Source/cmAddDependenciesCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddDependenciesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddDependenciesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_dependencies"; } + std::string GetName() const CM_OVERRIDE { return "add_dependencies"; } cmTypeMacro(cmAddDependenciesCommand, cmCommand); }; diff --git a/Source/cmAddExecutableCommand.h b/Source/cmAddExecutableCommand.h index 1e3181f..133f5bf 100644 --- a/Source/cmAddExecutableCommand.h +++ b/Source/cmAddExecutableCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddExecutableCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddExecutableCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_executable"; } + std::string GetName() const CM_OVERRIDE { return "add_executable"; } cmTypeMacro(cmAddExecutableCommand, cmCommand); }; diff --git a/Source/cmAddLibraryCommand.h b/Source/cmAddLibraryCommand.h index 0f0f768..20f1bc9 100644 --- a/Source/cmAddLibraryCommand.h +++ b/Source/cmAddLibraryCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddLibraryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddLibraryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_library"; } + std::string GetName() const CM_OVERRIDE { return "add_library"; } cmTypeMacro(cmAddLibraryCommand, cmCommand); }; diff --git a/Source/cmAddSubDirectoryCommand.h b/Source/cmAddSubDirectoryCommand.h index 786c8b0..ec1d2c8 100644 --- a/Source/cmAddSubDirectoryCommand.h +++ b/Source/cmAddSubDirectoryCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddSubDirectoryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddSubDirectoryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_subdirectory"; } + std::string GetName() const CM_OVERRIDE { return "add_subdirectory"; } cmTypeMacro(cmAddSubDirectoryCommand, cmCommand); }; diff --git a/Source/cmAddTestCommand.h b/Source/cmAddTestCommand.h index 295fb78..abff0c2 100644 --- a/Source/cmAddTestCommand.h +++ b/Source/cmAddTestCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAddTestCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAddTestCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "add_test"; } + std::string GetName() const CM_OVERRIDE { return "add_test"; } cmTypeMacro(cmAddTestCommand, cmCommand); diff --git a/Source/cmArchiveWrite.cxx b/Source/cmArchiveWrite.cxx index 235cf88..ceb7d31 100644 --- a/Source/cmArchiveWrite.cxx +++ b/Source/cmArchiveWrite.cxx @@ -151,9 +151,9 @@ cmArchiveWrite::cmArchiveWrite(std::ostream& os, Compress c, } if (archive_write_open( - this->Archive, this, 0, + this->Archive, this, CM_NULLPTR, reinterpret_cast<archive_write_callback*>(&Callback::Write), - 0) != ARCHIVE_OK) { + CM_NULLPTR) != ARCHIVE_OK) { this->Error = "archive_write_open: "; this->Error += cm_archive_error_string(this->Archive); return; @@ -229,7 +229,8 @@ bool cmArchiveWrite::AddFile(const char* file, size_t skip, const char* prefix) Entry e; cm_archive_entry_copy_sourcepath(e, file); cm_archive_entry_copy_pathname(e, dest); - if (archive_read_disk_entry_from_file(this->Disk, e, -1, 0) != ARCHIVE_OK) { + if (archive_read_disk_entry_from_file(this->Disk, e, -1, CM_NULLPTR) != + ARCHIVE_OK) { this->Error = "archive_read_disk_entry_from_file '"; this->Error += file; this->Error += "': "; diff --git a/Source/cmArchiveWrite.h b/Source/cmArchiveWrite.h index 72d8f3a..f847d09 100644 --- a/Source/cmArchiveWrite.h +++ b/Source/cmArchiveWrite.h @@ -72,13 +72,13 @@ public: * skip. The remaining part of the input path is appended to the * "prefix" value to construct the final name in the archive. */ - bool Add(std::string path, size_t skip = 0, const char* prefix = 0, + bool Add(std::string path, size_t skip = 0, const char* prefix = CM_NULLPTR, bool recursive = true); /** Returns true if there has been no error. */ operator safe_bool() const { - return this->Okay() ? &cmArchiveWrite::safe_bool_true : 0; + return this->Okay() ? &cmArchiveWrite::safe_bool_true : CM_NULLPTR; } /** Returns true if there has been an error. */ diff --git a/Source/cmAuxSourceDirectoryCommand.h b/Source/cmAuxSourceDirectoryCommand.h index b5943f5..6301cb2 100644 --- a/Source/cmAuxSourceDirectoryCommand.h +++ b/Source/cmAuxSourceDirectoryCommand.h @@ -29,19 +29,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmAuxSourceDirectoryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmAuxSourceDirectoryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "aux_source_directory"; } + std::string GetName() const CM_OVERRIDE { return "aux_source_directory"; } cmTypeMacro(cmAuxSourceDirectoryCommand, cmCommand); }; diff --git a/Source/cmBreakCommand.h b/Source/cmBreakCommand.h index 270d3e6..3b585e2 100644 --- a/Source/cmBreakCommand.h +++ b/Source/cmBreakCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmBreakCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmBreakCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "break"; } + std::string GetName() const CM_OVERRIDE { return "break"; } cmTypeMacro(cmBreakCommand, cmCommand); }; diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx index 586e8a8..fb143a2 100644 --- a/Source/cmBuildCommand.cxx +++ b/Source/cmBuildCommand.cxx @@ -36,8 +36,8 @@ bool cmBuildCommand::MainSignature(std::vector<std::string> const& args) const char* variable = args[0].c_str(); // Parse remaining arguments. - const char* configuration = 0; - const char* project_name = 0; + const char* configuration = CM_NULLPTR; + const char* project_name = CM_NULLPTR; std::string target; enum Doing { diff --git a/Source/cmBuildCommand.h b/Source/cmBuildCommand.h index 6cbf3ca..552e5ff 100644 --- a/Source/cmBuildCommand.h +++ b/Source/cmBuildCommand.h @@ -25,14 +25,14 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmBuildCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmBuildCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The primary command signature with optional, KEYWORD-based args. @@ -47,7 +47,7 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "build_command"; } + std::string GetName() const CM_OVERRIDE { return "build_command"; } cmTypeMacro(cmBuildCommand, cmCommand); diff --git a/Source/cmBuildNameCommand.h b/Source/cmBuildNameCommand.h index 43c24b0..4a1641bd 100644 --- a/Source/cmBuildNameCommand.h +++ b/Source/cmBuildNameCommand.h @@ -18,11 +18,11 @@ class cmBuildNameCommand : public cmCommand { public: cmTypeMacro(cmBuildNameCommand, cmCommand); - virtual cmCommand* Clone() { return new cmBuildNameCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "build_name"; } - virtual bool IsScriptable() const { return true; } + cmCommand* Clone() CM_OVERRIDE { return new cmBuildNameCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "build_name"; } + bool IsScriptable() const CM_OVERRIDE { return true; } }; #endif diff --git a/Source/cmCMakeHostSystemInformationCommand.h b/Source/cmCMakeHostSystemInformationCommand.h index 6981ea9..8e6f0f5 100644 --- a/Source/cmCMakeHostSystemInformationCommand.h +++ b/Source/cmCMakeHostSystemInformationCommand.h @@ -28,7 +28,7 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { return new cmCMakeHostSystemInformationCommand; } @@ -37,18 +37,18 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return "cmake_host_system_information"; } diff --git a/Source/cmCMakeMinimumRequired.h b/Source/cmCMakeMinimumRequired.h index fc73e87..4231eb4 100644 --- a/Source/cmCMakeMinimumRequired.h +++ b/Source/cmCMakeMinimumRequired.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmCMakeMinimumRequired; } + cmCommand* Clone() CM_OVERRIDE { return new cmCMakeMinimumRequired; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "cmake_minimum_required"; } + std::string GetName() const CM_OVERRIDE { return "cmake_minimum_required"; } cmTypeMacro(cmCMakeMinimumRequired, cmCommand); diff --git a/Source/cmCMakePolicyCommand.h b/Source/cmCMakePolicyCommand.h index dbb91d5..fd4ab0a 100644 --- a/Source/cmCMakePolicyCommand.h +++ b/Source/cmCMakePolicyCommand.h @@ -26,24 +26,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmCMakePolicyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmCMakePolicyCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "cmake_policy"; } + std::string GetName() const CM_OVERRIDE { return "cmake_policy"; } cmTypeMacro(cmCMakePolicyCommand, cmCommand); diff --git a/Source/cmCPackPropertiesGenerator.h b/Source/cmCPackPropertiesGenerator.h index 4372b87..4d092f6 100644 --- a/Source/cmCPackPropertiesGenerator.h +++ b/Source/cmCPackPropertiesGenerator.h @@ -29,9 +29,8 @@ public: std::vector<std::string> const& configurations); protected: - virtual void GenerateScriptForConfig(std::ostream& os, - const std::string& config, - Indent const& indent); + void GenerateScriptForConfig(std::ostream& os, const std::string& config, + Indent const& indent) CM_OVERRIDE; cmLocalGenerator* LG; cmInstalledFile const& InstalledFile; diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx index a78300c..f97791a 100644 --- a/Source/cmCPluginAPI.cxx +++ b/Source/cmCPluginAPI.cxx @@ -218,8 +218,8 @@ void CCONV cmAddUtilityCommand(void* arg, const char* utilityName, } // Pass the call to the makefile instance. - mf->AddUtilityCommand(utilityName, (all ? false : true), 0, depends2, - commandLines); + mf->AddUtilityCommand(utilityName, (all ? false : true), CM_NULLPTR, + depends2, commandLines); } void CCONV cmAddCustomCommand(void* arg, const char* source, const char* command, int numArgs, @@ -257,7 +257,7 @@ void CCONV cmAddCustomCommand(void* arg, const char* source, } // Pass the call to the makefile instance. - const char* no_comment = 0; + const char* no_comment = CM_NULLPTR; mf->AddCustomCommandOldStyle(target, outputs2, depends2, source, commandLines, no_comment); } @@ -291,8 +291,8 @@ void CCONV cmAddCustomCommandToOutput(void* arg, const char* output, } // Pass the call to the makefile instance. - const char* no_comment = 0; - const char* no_working_dir = 0; + const char* no_comment = CM_NULLPTR; + const char* no_working_dir = CM_NULLPTR; mf->AddCustomCommandToOutput(output, depends2, main_dependency, commandLines, no_comment, no_working_dir); } @@ -333,8 +333,8 @@ void CCONV cmAddCustomCommandToTarget(void* arg, const char* target, // Pass the call to the makefile instance. std::vector<std::string> no_byproducts; std::vector<std::string> no_depends; - const char* no_comment = 0; - const char* no_working_dir = 0; + const char* no_comment = CM_NULLPTR; + const char* no_working_dir = CM_NULLPTR; mf->AddCustomCommandToTarget(target, no_byproducts, no_depends, commandLines, cctype, no_comment, no_working_dir); } @@ -414,7 +414,7 @@ void CCONV cmExpandSourceListArguments(void* arg, int numArgs, result.push_back(args[i]); } int resargc = static_cast<int>(result.size()); - char** resargv = 0; + char** resargv = CM_NULLPTR; if (resargc) { resargv = (char**)malloc(resargc * sizeof(char*)); } @@ -453,7 +453,7 @@ int CCONV cmGetTotalArgumentSize(int argc, char** argv) struct cmCPluginAPISourceFile { cmCPluginAPISourceFile() - : RealSourceFile(0) + : RealSourceFile(CM_NULLPTR) { } cmSourceFile* RealSourceFile; @@ -525,7 +525,7 @@ void CCONV* cmGetSource(void* arg, const char* name) } return (void*)i->second; } else { - return 0; + return CM_NULLPTR; } } @@ -534,7 +534,7 @@ void* CCONV cmAddSource(void* arg, void* arg2) cmMakefile* mf = static_cast<cmMakefile*>(arg); cmCPluginAPISourceFile* osf = static_cast<cmCPluginAPISourceFile*>(arg2); if (osf->FullPath.empty()) { - return 0; + return CM_NULLPTR; } // Create the real cmSourceFile instance and copy over saved information. diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx index 2e47298..9950a84 100644 --- a/Source/cmCTest.cxx +++ b/Source/cmCTest.cxx @@ -51,7 +51,7 @@ #include <math.h> #include <stdlib.h> -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> #include <cm_zlib.h> #include <cmsys/Base64.h> @@ -70,7 +70,7 @@ struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag) { struct tm* lctime; - time_t tctime = time(0); + time_t tctime = time(CM_NULLPTR); lctime = gmtime(&tctime); char buf[1024]; // add todays year day and month to the time in str because @@ -88,7 +88,7 @@ struct tm* cmCTest::GetNightlyTime(std::string const& str, bool tomorrowtag) // As such, this time may be in the past or in the future. time_t ntime = curl_getdate(buf, &tctime); cmCTestLog(this, DEBUG, " Get curl time: " << ntime << std::endl); - tctime = time(0); + tctime = time(CM_NULLPTR); cmCTestLog(this, DEBUG, " Get the current time: " << tctime << std::endl); const int dayLength = 24 * 60 * 60; @@ -134,7 +134,7 @@ std::string cmCTest::CleanString(const std::string& str) std::string cmCTest::CurrentTime() { - time_t currenttime = time(0); + time_t currenttime = time(CM_NULLPTR); struct tm* t = localtime(¤ttime); // return ::CleanString(ctime(¤ttime)); char current_time[1024]; @@ -244,7 +244,7 @@ std::string cmCTest::DecodeURL(const std::string& in) for (const char* c = in.c_str(); *c; ++c) { if (*c == '%' && isxdigit(*(c + 1)) && isxdigit(*(c + 2))) { char buf[3] = { *(c + 1), *(c + 2), 0 }; - out.append(1, char(strtoul(buf, 0, 16))); + out.append(1, char(strtoul(buf, CM_NULLPTR, 16))); c += 2; } else { out.append(1, *c); @@ -288,7 +288,7 @@ cmCTest::cmCTest() this->ScheduleType = ""; this->StopTime = ""; this->NextDayStopTime = false; - this->OutputLogFile = 0; + this->OutputLogFile = CM_NULLPTR; this->OutputLogFileLastTag = -1; this->SuppressUpdatingCTestConfiguration = false; this->DartVersion = 1; @@ -347,7 +347,7 @@ cmCTest::cmCTest() cmCTest::~cmCTest() { cmDeleteAll(this->TestingHandlers); - this->SetOutputLogFileName(0); + this->SetOutputLogFileName(CM_NULLPTR); } void cmCTest::SetParallelLevel(int level) @@ -474,7 +474,7 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); if (!this->ReadCustomConfigurationFileTree(this->BinaryDir.c_str(), mf.get())) { cmCTestOptionalLog( @@ -515,7 +515,7 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) std::string tag; if (createNewTag) { - time_t tctime = time(0); + time_t tctime = time(CM_NULLPTR); if (this->TomorrowTag) { tctime += (24 * 60 * 60); } @@ -540,7 +540,7 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) } tfin.close(); } - if (tag.empty() || (0 != command) || this->Parts[PartStart]) { + if (tag.empty() || (CM_NULLPTR != command) || this->Parts[PartStart]) { cmCTestOptionalLog( this, DEBUG, "TestModel: " << this->GetTestModelString() << std::endl, quiet); @@ -562,7 +562,7 @@ int cmCTest::Initialize(const char* binary_dir, cmCTestStartCommand* command) ofs << this->GetTestModelString() << std::endl; } ofs.close(); - if (0 == command) { + if (CM_NULLPTR == command) { cmCTestOptionalLog(this, OUTPUT, "Create new tag: " << tag << " - " << this->GetTestModelString() << std::endl, @@ -860,7 +860,7 @@ cmCTestGenericHandler* cmCTest::GetInitializedHandler(const char* handler) cmCTest::t_TestingHandlers::iterator it = this->TestingHandlers.find(handler); if (it == this->TestingHandlers.end()) { - return 0; + return CM_NULLPTR; } it->second->Initialize(); return it->second; @@ -871,7 +871,7 @@ cmCTestGenericHandler* cmCTest::GetHandler(const char* handler) cmCTest::t_TestingHandlers::iterator it = this->TestingHandlers.find(handler); if (it == this->TestingHandlers.end()) { - return 0; + return CM_NULLPTR; } return it->second; } @@ -1029,7 +1029,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output, a != args.end(); ++a) { argv.push_back(a->c_str()); } - argv.push_back(0); + argv.push_back(CM_NULLPTR); output = ""; cmCTestLog(this, HANDLER_VERBOSE_OUTPUT, "Run command:"); @@ -1057,7 +1057,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output, cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, " Each . represents " << tick_len << " bytes of output" << std::endl << " " << std::flush); - while (cmsysProcess_WaitForData(cp, &data, &length, 0)) { + while (cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR)) { for (int cc = 0; cc < length; ++cc) { if (data[cc] == 0) { data[cc] = '\n'; @@ -1082,7 +1082,7 @@ int cmCTest::RunMakeCommand(const char* command, std::string& output, cmCTestLog(this, HANDLER_PROGRESS_OUTPUT, " Size of output: " << int(double(output.size()) / 1024.0) << "K" << std::endl); - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); int result = cmsysProcess_GetState(cp); @@ -1165,7 +1165,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output, } std::string oldpath = cmSystemTools::GetCurrentWorkingDirectory(); - cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv; + CM_AUTO_PTR<cmSystemTools::SaveRestoreEnvironment> saveEnv; if (modifyEnv) { saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment); cmSystemTools::AppendEnv(*environment); @@ -1193,7 +1193,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output, *output = ""; } - cmsys::auto_ptr<cmSystemTools::SaveRestoreEnvironment> saveEnv; + CM_AUTO_PTR<cmSystemTools::SaveRestoreEnvironment> saveEnv; if (modifyEnv) { saveEnv.reset(new cmSystemTools::SaveRestoreEnvironment); cmSystemTools::AppendEnv(*environment); @@ -1211,7 +1211,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output, char* data; int length; - while (cmsysProcess_WaitForData(cp, &data, &length, 0)) { + while (cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR)) { if (output) { tempOutput.insert(tempOutput.end(), data, data + length); } @@ -1221,7 +1221,7 @@ int cmCTest::RunTest(std::vector<const char*> argv, std::string* output, } } - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); if (output && tempOutput.begin() != tempOutput.end()) { output->append(&*tempOutput.begin(), tempOutput.size()); } @@ -2181,7 +2181,7 @@ int cmCTest::Run(std::vector<std::string>& args, std::string* output) it->second->SetSubmitIndex(this->SubmitIndex); } std::string cwd = cmSystemTools::GetCurrentWorkingDirectory(); - if (!this->Initialize(cwd.c_str(), 0)) { + if (!this->Initialize(cwd.c_str(), CM_NULLPTR)) { res = 12; cmCTestLog(this, ERROR_MESSAGE, "Problem initializing the dashboard." << std::endl); @@ -2325,7 +2325,7 @@ std::string cmCTest::GetShortPathToFile(const char* cfname) bool inBld = bldRelpath.find("..") == bldRelpath.npos; // TODO: Handle files with .. in their name - std::string* res = 0; + std::string* res = CM_NULLPTR; if (inSrc && inBld) { // If both have relative path with no dots, pick the shorter one @@ -2375,7 +2375,7 @@ void cmCTest::EmptyCTestConfiguration() void cmCTest::DetermineNextDayStop() { struct tm* lctime; - time_t current_time = time(0); + time_t current_time = time(CM_NULLPTR); lctime = gmtime(¤t_time); int gm_hour = lctime->tm_hour; time_t gm_time = mktime(lctime); @@ -2459,7 +2459,7 @@ bool cmCTest::GetProduceXML() const char* cmCTest::GetSpecificTrack() { if (this->SpecificTrack.empty()) { - return 0; + return CM_NULLPTR; } return this->SpecificTrack.c_str(); } @@ -2534,7 +2534,7 @@ bool cmCTest::RunCommand(const char* command, std::string* stdOut, a != args.end(); ++a) { argv.push_back(a->c_str()); } - argv.push_back(0); + argv.push_back(CM_NULLPTR); *stdOut = ""; *stdErr = ""; @@ -2555,7 +2555,7 @@ bool cmCTest::RunCommand(const char* command, std::string* stdOut, int res; bool done = false; while (!done) { - res = cmsysProcess_WaitForData(cp, &data, &length, 0); + res = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR); switch (res) { case cmsysProcess_Pipe_STDOUT: tempOutput.insert(tempOutput.end(), data, data + length); @@ -2572,7 +2572,7 @@ bool cmCTest::RunCommand(const char* command, std::string* stdOut, } } - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); if (!tempOutput.empty()) { stdOut->append(&*tempOutput.begin(), tempOutput.size()); } @@ -2614,7 +2614,7 @@ void cmCTest::SetOutputLogFileName(const char* name) { if (this->OutputLogFile) { delete this->OutputLogFile; - this->OutputLogFile = 0; + this->OutputLogFile = CM_NULLPTR; } if (name) { this->OutputLogFile = new cmGeneratedFileStream(name); @@ -2628,7 +2628,7 @@ static const char* cmCTestStringLogType[] = { "DEBUG", "HANDLER_VERBOSE_OUTPUT", "WARNING", "ERROR_MESSAGE", - 0 }; + CM_NULLPTR }; #ifdef cerr #undef cerr diff --git a/Source/cmCTest.h b/Source/cmCTest.h index 65ecaa4..833cd96 100644 --- a/Source/cmCTest.h +++ b/Source/cmCTest.h @@ -120,7 +120,7 @@ public: typedef std::set<std::string> SetOfStrings; ///! Process Command line arguments - int Run(std::vector<std::string>&, std::string* output = 0); + int Run(std::vector<std::string>&, std::string* output = CM_NULLPTR); /** * Initialize and finalize testing @@ -271,8 +271,8 @@ public: * escaped for this to with spaces. */ bool RunCommand(const char* command, std::string* stdOut, - std::string* stdErr, int* retVal = 0, const char* dir = 0, - double timeout = 0.0); + std::string* stdErr, int* retVal = CM_NULLPTR, + const char* dir = CM_NULLPTR, double timeout = 0.0); //! Clean/make safe for xml the given value such that it may be used as // one of the key fields by CDash when computing the buildid. @@ -574,7 +574,7 @@ private: //! Check if the argument is the one specified bool CheckArgument(const std::string& arg, const char* varg1, - const char* varg2 = 0); + const char* varg2 = CM_NULLPTR); //! Output errors from a test void OutputTestErrors(std::vector<char> const& process_output); diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx index bcef3c8..bdd7303 100644 --- a/Source/cmCacheManager.cxx +++ b/Source/cmCacheManager.cxx @@ -179,7 +179,7 @@ bool cmCacheManager::LoadCache(const std::string& path, bool internal, } const char* cmCacheManager::PersistentProperties[] = { "ADVANCED", "MODIFIED", - "STRINGS", 0 }; + "STRINGS", CM_NULLPTR }; bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey, CacheEntry& e) @@ -447,7 +447,7 @@ cmCacheManager::CacheEntry* cmCacheManager::GetCacheEntry( if (i != this->Cache.end()) { return &i->second; } - return 0; + return CM_NULLPTR; } cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(const char* key) @@ -462,7 +462,7 @@ const char* cmCacheManager::GetInitializedCacheValue( if (i != this->Cache.end() && i->second.Initialized) { return i->second.Value.c_str(); } - return 0; + return CM_NULLPTR; } void cmCacheManager::PrintCache(std::ostream& out) const @@ -616,7 +616,7 @@ const char* cmCacheManager::CacheIterator::GetProperty( if (!this->IsAtEnd()) { return this->GetEntry().GetProperty(prop); } - return 0; + return CM_NULLPTR; } void cmCacheManager::CacheIterator::SetProperty(const std::string& p, @@ -653,5 +653,5 @@ void cmCacheManager::CacheIterator::SetProperty(const std::string& p, bool v) bool cmCacheManager::CacheIterator::PropertyExists( const std::string& prop) const { - return this->GetProperty(prop) != NULL; + return this->GetProperty(prop) != CM_NULLPTR; } diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h index 153e957..2331867 100644 --- a/Source/cmCacheManager.h +++ b/Source/cmCacheManager.h @@ -113,7 +113,7 @@ public: void PrintCache(std::ostream&) const; ///! Get the iterator for an entry with a given key. - cmCacheManager::CacheIterator GetCacheIterator(const char* key = 0); + cmCacheManager::CacheIterator GetCacheIterator(const char* key = CM_NULLPTR); ///! Remove an entry from the cache void RemoveCacheEntry(const std::string& key); @@ -128,7 +128,7 @@ public: { cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str()); if (it.IsAtEnd()) { - return 0; + return CM_NULLPTR; } return it.GetValue(); } @@ -171,7 +171,8 @@ public: void RemoveCacheEntryProperty(std::string const& key, std::string const& propName) { - this->GetCacheIterator(key.c_str()).SetProperty(propName, (void*)0); + this->GetCacheIterator(key.c_str()) + .SetProperty(propName, (void*)CM_NULLPTR); } void AppendCacheEntryProperty(std::string const& key, diff --git a/Source/cmCommand.h b/Source/cmCommand.h index 0157293..a5f20e6 100644 --- a/Source/cmCommand.h +++ b/Source/cmCommand.h @@ -38,14 +38,14 @@ public: */ cmCommand() { - this->Makefile = 0; + this->Makefile = CM_NULLPTR; this->Enabled = true; } /** * Need virtual destructor to destroy real command type. */ - virtual ~cmCommand() {} + ~cmCommand() CM_OVERRIDE {} /** * Specify the makefile. diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx index a4f3c7d..294117c 100644 --- a/Source/cmCommandArgumentParserHelper.cxx +++ b/Source/cmCommandArgumentParserHelper.cxx @@ -25,7 +25,7 @@ cmCommandArgumentParserHelper::cmCommandArgumentParserHelper() this->WarnUninitialized = false; this->CheckSystemVars = false; this->FileLine = -1; - this->FileName = 0; + this->FileName = CM_NULLPTR; this->RemoveEmpty = true; this->EmptyVariable[0] = 0; strcpy(this->DCURLYVariable, "${"); @@ -96,13 +96,13 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key, e << "Syntax $" << key << "{} is not supported. " << "Only ${}, $ENV{}, and $CACHE{} are allowed."; this->SetError(e.str()); - return 0; + return CM_NULLPTR; } char* cmCommandArgumentParserHelper::ExpandVariable(const char* var) { if (!var) { - return 0; + return CM_NULLPTR; } if (this->FileLine >= 0 && strcmp(var, "CMAKE_CURRENT_LIST_LINE") == 0) { std::ostringstream ostr; @@ -125,7 +125,7 @@ char* cmCommandArgumentParserHelper::ExpandVariable(const char* var) this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, msg.str()); } } - return 0; + return CM_NULLPTR; } if (this->EscapeQuotes && value) { return this->AddString(cmSystemTools::EscapeQuotes(value)); @@ -176,7 +176,7 @@ char* cmCommandArgumentParserHelper::CombineUnions(char* in1, char* in2) void cmCommandArgumentParserHelper::AllocateParserType( cmCommandArgumentParserHelper::ParserType* pt, const char* str, int len) { - pt->str = 0; + pt->str = CM_NULLPTR; if (len == 0) { len = static_cast<int>(strlen(str)); } diff --git a/Source/cmCommandArgumentsHelper.cxx b/Source/cmCommandArgumentsHelper.cxx index c336bc5..1345bd5 100644 --- a/Source/cmCommandArgumentsHelper.cxx +++ b/Source/cmCommandArgumentsHelper.cxx @@ -21,11 +21,11 @@ cmCommandArgument::cmCommandArgument(cmCommandArgumentsHelper* args, , ArgumentsBeforeEmpty(true) , CurrentIndex(0) { - if (args != 0) { + if (args != CM_NULLPTR) { args->AddArgument(this); } - if (this->Group != 0) { + if (this->Group != CM_NULLPTR) { this->Group->ContainedArguments.push_back(this); } } @@ -45,7 +45,7 @@ void cmCommandArgument::Follows(const cmCommandArgument* arg) void cmCommandArgument::FollowsGroup(const cmCommandArgumentGroup* group) { - if (group != 0) { + if (group != CM_NULLPTR) { this->ArgumentsBeforeEmpty = false; this->ArgumentsBefore.insert(group->ContainedArguments.begin(), group->ContainedArguments.end()); @@ -69,7 +69,7 @@ bool cmCommandArgument::MayFollow(const cmCommandArgument* current) const bool cmCommandArgument::KeyMatches(const std::string& key) const { - if ((this->Key == 0) || (this->Key[0] == '\0')) { + if ((this->Key == CM_NULLPTR) || (this->Key[0] == '\0')) { return true; } return (key == this->Key); @@ -77,7 +77,7 @@ bool cmCommandArgument::KeyMatches(const std::string& key) const void cmCommandArgument::ApplyOwnGroup() { - if (this->Group != 0) { + if (this->Group != CM_NULLPTR) { for (std::vector<cmCommandArgument*>::const_iterator it = this->Group->ContainedArguments.begin(); it != this->Group->ContainedArguments.end(); ++it) { @@ -105,9 +105,9 @@ cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args, const char* key, cmCommandArgumentGroup* group) : cmCommandArgument(args, key, group) - , Ignore(0) + , Ignore(CM_NULLPTR) { - if ((key == 0) || (*key == 0)) { + if ((key == CM_NULLPTR) || (*key == 0)) { this->DataStart = 0; } else { this->DataStart = 1; @@ -117,7 +117,7 @@ cmCAStringVector::cmCAStringVector(cmCommandArgumentsHelper* args, bool cmCAStringVector::DoConsume(const std::string& arg, unsigned int index) { if (index >= this->DataStart) { - if ((this->Ignore == 0) || (arg != this->Ignore)) { + if ((this->Ignore == CM_NULLPTR) || (arg != this->Ignore)) { this->Vector.push_back(arg); } } @@ -134,7 +134,7 @@ cmCAString::cmCAString(cmCommandArgumentsHelper* args, const char* key, cmCommandArgumentGroup* group) : cmCommandArgument(args, key, group) { - if ((key == 0) || (*key == 0)) { + if ((key == CM_NULLPTR) || (*key == 0)) { this->DataStart = 0; } else { this->DataStart = 1; @@ -216,7 +216,7 @@ void cmCommandArgumentGroup::FollowsGroup(const cmCommandArgumentGroup* group) void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args, std::vector<std::string>* unconsumedArgs) { - if (args == 0) { + if (args == CM_NULLPTR) { return; } @@ -227,8 +227,8 @@ void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args, (*argIt)->Reset(); } - cmCommandArgument* activeArgument = 0; - const cmCommandArgument* previousArgument = 0; + cmCommandArgument* activeArgument = CM_NULLPTR; + const cmCommandArgument* previousArgument = CM_NULLPTR; for (std::vector<std::string>::const_iterator it = args->begin(); it != args->end(); ++it) { for (std::vector<cmCommandArgument*>::iterator argIt = @@ -246,10 +246,10 @@ void cmCommandArgumentsHelper::Parse(const std::vector<std::string>* args, bool argDone = activeArgument->Consume(*it); previousArgument = activeArgument; if (argDone) { - activeArgument = 0; + activeArgument = CM_NULLPTR; } } else { - if (unconsumedArgs != 0) { + if (unconsumedArgs != CM_NULLPTR) { unconsumedArgs->push_back(*it); } } diff --git a/Source/cmCommandArgumentsHelper.h b/Source/cmCommandArgumentsHelper.h index c2a6f92..9133148 100644 --- a/Source/cmCommandArgumentsHelper.h +++ b/Source/cmCommandArgumentsHelper.h @@ -43,7 +43,7 @@ class cmCommandArgument { public: cmCommandArgument(cmCommandArgumentsHelper* args, const char* key, - cmCommandArgumentGroup* group = 0); + cmCommandArgumentGroup* group = CM_NULLPTR); virtual ~cmCommandArgument() {} /// this argument may follow after arg. 0 means it comes first. @@ -95,7 +95,7 @@ class cmCAStringVector : public cmCommandArgument { public: cmCAStringVector(cmCommandArgumentsHelper* args, const char* key, - cmCommandArgumentGroup* group = 0); + cmCommandArgumentGroup* group = CM_NULLPTR); /// Return the vector of strings const std::vector<std::string>& GetVector() const { return this->Vector; } @@ -108,8 +108,8 @@ private: unsigned int DataStart; const char* Ignore; cmCAStringVector(); - virtual bool DoConsume(const std::string& arg, unsigned int index); - virtual void DoReset(); + bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE; + void DoReset() CM_OVERRIDE; }; /** cmCAString is to be used for arguments which consist of one value, @@ -118,7 +118,7 @@ class cmCAString : public cmCommandArgument { public: cmCAString(cmCommandArgumentsHelper* args, const char* key, - cmCommandArgumentGroup* group = 0); + cmCommandArgumentGroup* group = CM_NULLPTR); /// Return the string const std::string& GetString() const { return this->String; } @@ -126,8 +126,8 @@ public: private: std::string String; unsigned int DataStart; - virtual bool DoConsume(const std::string& arg, unsigned int index); - virtual void DoReset(); + bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE; + void DoReset() CM_OVERRIDE; cmCAString(); }; @@ -137,14 +137,14 @@ class cmCAEnabler : public cmCommandArgument { public: cmCAEnabler(cmCommandArgumentsHelper* args, const char* key, - cmCommandArgumentGroup* group = 0); + cmCommandArgumentGroup* group = CM_NULLPTR); /// Has it been enabled ? bool IsEnabled() const { return this->Enabled; } private: bool Enabled; - virtual bool DoConsume(const std::string& arg, unsigned int index); - virtual void DoReset(); + bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE; + void DoReset() CM_OVERRIDE; cmCAEnabler(); }; @@ -154,14 +154,14 @@ class cmCADisabler : public cmCommandArgument { public: cmCADisabler(cmCommandArgumentsHelper* args, const char* key, - cmCommandArgumentGroup* group = 0); + cmCommandArgumentGroup* group = CM_NULLPTR); /// Is it still enabled ? bool IsEnabled() const { return this->Enabled; } private: bool Enabled; - virtual bool DoConsume(const std::string& arg, unsigned int index); - virtual void DoReset(); + bool DoConsume(const std::string& arg, unsigned int index) CM_OVERRIDE; + void DoReset() CM_OVERRIDE; cmCADisabler(); }; diff --git a/Source/cmCommonTargetGenerator.cxx b/Source/cmCommonTargetGenerator.cxx index 101093d..7ad18f0 100644 --- a/Source/cmCommonTargetGenerator.cxx +++ b/Source/cmCommonTargetGenerator.cxx @@ -98,7 +98,7 @@ void cmCommonTargetGenerator::AppendFortranFormatFlags( const char* tgtfmt = this->GeneratorTarget->GetProperty("Fortran_FORMAT"); format = cmOutputConverter::GetFortranFormat(tgtfmt); } - const char* var = 0; + const char* var = CM_NULLPTR; switch (format) { case cmOutputConverter::FortranFormatFixed: var = "CMAKE_Fortran_FORMAT_FIXED_FLAG"; diff --git a/Source/cmComputeLinkDepends.cxx b/Source/cmComputeLinkDepends.cxx index 2129394..fffb77d 100644 --- a/Source/cmComputeLinkDepends.cxx +++ b/Source/cmComputeLinkDepends.cxx @@ -194,7 +194,7 @@ cmComputeLinkDepends::cmComputeLinkDepends(const cmGeneratorTarget* target, this->OldLinkDirMode = false; // No computation has been done. - this->CCG = 0; + this->CCG = CM_NULLPTR; } cmComputeLinkDepends::~cmComputeLinkDepends() @@ -286,7 +286,7 @@ std::map<std::string, int>::iterator cmComputeLinkDepends::AllocateLinkEntry( std::map<std::string, int>::iterator lei = this->LinkEntryIndex.insert(index_entry).first; this->EntryList.push_back(LinkEntry()); - this->InferredDependSets.push_back(0); + this->InferredDependSets.push_back(CM_NULLPTR); this->EntryConstraintGraph.push_back(EdgeList()); return lei; } @@ -314,7 +314,7 @@ int cmComputeLinkDepends::AddLinkEntry(cmLinkItem const& item) // If the item has dependencies queue it to follow them. if (entry.Target) { // Target dependencies are always known. Follow them. - BFSEntry qe = { index, 0 }; + BFSEntry qe = { index, CM_NULLPTR }; this->BFSQueue.push(qe); } else { // Look for an old-style <item>_LIB_DEPENDS variable. diff --git a/Source/cmComputeLinkDepends.h b/Source/cmComputeLinkDepends.h index 6aa40c3..4a33aff 100644 --- a/Source/cmComputeLinkDepends.h +++ b/Source/cmComputeLinkDepends.h @@ -44,7 +44,7 @@ public: bool IsFlag; LinkEntry() : Item() - , Target(0) + , Target(CM_NULLPTR) , IsSharedDep(false) , IsFlag(false) { diff --git a/Source/cmComputeLinkInformation.cxx b/Source/cmComputeLinkInformation.cxx index 1eefbb1..7db5df3 100644 --- a/Source/cmComputeLinkInformation.cxx +++ b/Source/cmComputeLinkInformation.cxx @@ -262,7 +262,7 @@ cmComputeLinkInformation::cmComputeLinkInformation( this->GlobalGenerator, target, "linker search path"); this->OrderRuntimeSearchPath = new cmOrderDirectories( this->GlobalGenerator, target, "runtime search path"); - this->OrderDependentRPath = 0; + this->OrderDependentRPath = CM_NULLPTR; // Get the language used for linking this target. this->LinkLanguage = this->Target->GetLinkerLanguage(config); @@ -283,7 +283,7 @@ cmComputeLinkInformation::cmComputeLinkInformation( // On platforms without import libraries there may be a special flag // to use when creating a plugin (module) that obtains symbols from // the program that will load it. - this->LoaderFlag = 0; + this->LoaderFlag = CM_NULLPTR; if (!this->UseImportLibrary && this->Target->GetType() == cmState::MODULE_LIBRARY) { std::string loader_flag_var = "CMAKE_SHARED_MODULE_LOADER_"; @@ -561,7 +561,7 @@ void cmComputeLinkInformation::AddImplicitLinkInfo(std::string const& lang) for (std::vector<std::string>::const_iterator i = libsVec.begin(); i != libsVec.end(); ++i) { if (this->ImplicitLinkLibs.find(*i) == this->ImplicitLinkLibs.end()) { - this->AddItem(*i, 0); + this->AddItem(*i, CM_NULLPTR); } } } @@ -693,7 +693,7 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, // Check if we need to include the dependent shared library in other // path ordering. - cmOrderDirectories* order = 0; + cmOrderDirectories* order = CM_NULLPTR; if (this->SharedDependencyMode == SharedDepModeLibDir && !this->LinkWithRuntimePath /* AddLibraryRuntimeInfo adds it */) { // Add the item to the linker search path. @@ -705,7 +705,7 @@ void cmComputeLinkInformation::AddSharedDepItem(std::string const& item, if (order) { if (tgt) { std::string soName = tgt->GetSOName(this->Config); - const char* soname = soName.empty() ? 0 : soName.c_str(); + const char* soname = soName.empty() ? CM_NULLPTR : soName.c_str(); order->AddRuntimeLibrary(lib, soname); } else { order->AddRuntimeLibrary(lib); @@ -724,9 +724,9 @@ void cmComputeLinkInformation::ComputeLinkTypeInfo() this->LinkTypeEnabled = false; // Lookup link type selection flags. - const char* static_link_type_flag = 0; - const char* shared_link_type_flag = 0; - const char* target_type_str = 0; + const char* static_link_type_flag = CM_NULLPTR; + const char* shared_link_type_flag = CM_NULLPTR; + const char* target_type_str = CM_NULLPTR; switch (this->Target->GetType()) { case cmState::EXECUTABLE: target_type_str = "EXE"; @@ -1606,7 +1606,7 @@ void cmComputeLinkInformation::AddLibraryRuntimeInfo( // Try to get the soname of the library. Only files with this name // could possibly conflict. std::string soName = target->GetSOName(this->Config); - const char* soname = soName.empty() ? 0 : soName.c_str(); + const char* soname = soName.empty() ? CM_NULLPTR : soName.c_str(); // Include this library in the runtime path ordering. this->OrderRuntimeSearchPath->AddRuntimeLibrary(fullPath, soname); diff --git a/Source/cmComputeLinkInformation.h b/Source/cmComputeLinkInformation.h index c0ddc53..023c781 100644 --- a/Source/cmComputeLinkInformation.h +++ b/Source/cmComputeLinkInformation.h @@ -38,7 +38,7 @@ public: Item() : Value() , IsPath(true) - , Target(0) + , Target(CM_NULLPTR) { } Item(Item const& item) @@ -47,7 +47,8 @@ public: , Target(item.Target) { } - Item(std::string const& v, bool p, cmGeneratorTarget const* target = 0) + Item(std::string const& v, bool p, + cmGeneratorTarget const* target = CM_NULLPTR) : Value(v) , IsPath(p) , Target(target) diff --git a/Source/cmComputeTargetDepends.cxx b/Source/cmComputeTargetDepends.cxx index 570405a..ff7eb0b 100644 --- a/Source/cmComputeTargetDepends.cxx +++ b/Source/cmComputeTargetDepends.cxx @@ -291,7 +291,7 @@ void cmComputeTargetDepends::AddInterfaceDepends( // within the project. if (dependee && dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { - dependee = 0; + dependee = CM_NULLPTR; } if (dependee) { @@ -355,7 +355,7 @@ void cmComputeTargetDepends::AddTargetDepend(int depender_index, // within the project. if (linking && dependee && dependee->GetType() == cmState::EXECUTABLE && !dependee->IsExecutableWithExports()) { - dependee = 0; + dependee = CM_NULLPTR; } if (dependee) { diff --git a/Source/cmConditionEvaluator.cxx b/Source/cmConditionEvaluator.cxx index 7006b62..67b2571 100644 --- a/Source/cmConditionEvaluator.cxx +++ b/Source/cmConditionEvaluator.cxx @@ -130,7 +130,7 @@ const char* cmConditionEvaluator::GetDefinitionIfUnquoted( if ((this->Policy54Status != cmPolicies::WARN && this->Policy54Status != cmPolicies::OLD) && argument.WasQuoted()) { - return 0; + return CM_NULLPTR; } const char* def = this->Makefile.GetDefinition(argument.GetValue()); diff --git a/Source/cmConfigure.cmake.h.in b/Source/cmConfigure.cmake.h.in index 938b10e..7e48b2d 100644 --- a/Source/cmConfigure.cmake.h.in +++ b/Source/cmConfigure.cmake.h.in @@ -29,8 +29,23 @@ #cmakedefine CMAKE_USE_ELF_PARSER #cmakedefine CMAKE_USE_MACH_PARSER #cmakedefine CMAKE_ENCODING_UTF8 -#cmakedefine CMake_HAVE_CXX11_UNORDERED_MAP +#cmakedefine CMake_HAVE_CXX_NULLPTR +#cmakedefine CMake_HAVE_CXX_OVERRIDE +#cmakedefine CMake_HAVE_CXX_UNORDERED_MAP +#cmakedefine CMake_HAVE_CXX_UNORDERED_SET #define CMAKE_BIN_DIR "/@CMAKE_BIN_DIR@" #define CMAKE_DATA_DIR "/@CMAKE_DATA_DIR@" +#ifdef CMake_HAVE_CXX_NULLPTR +#define CM_NULLPTR nullptr +#else +#define CM_NULLPTR 0 +#endif + +#ifdef CMake_HAVE_CXX_OVERRIDE +#define CM_OVERRIDE override +#else +#define CM_OVERRIDE +#endif + #endif diff --git a/Source/cmConfigureFileCommand.h b/Source/cmConfigureFileCommand.h index 79f00bc..1da65c8 100644 --- a/Source/cmConfigureFileCommand.h +++ b/Source/cmConfigureFileCommand.h @@ -19,24 +19,24 @@ class cmConfigureFileCommand : public cmCommand public: cmTypeMacro(cmConfigureFileCommand, cmCommand); - virtual cmCommand* Clone() { return new cmConfigureFileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmConfigureFileCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "configure_file"; } + std::string GetName() const CM_OVERRIDE { return "configure_file"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } private: int ConfigureFile(); diff --git a/Source/cmContinueCommand.h b/Source/cmContinueCommand.h index 63ae59d..6fa9af2 100644 --- a/Source/cmContinueCommand.h +++ b/Source/cmContinueCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmContinueCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmContinueCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "continue"; } + std::string GetName() const CM_OVERRIDE { return "continue"; } cmTypeMacro(cmContinueCommand, cmCommand); }; diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx index 0149fdf..e9367b1 100644 --- a/Source/cmCoreTryCompile.cxx +++ b/Source/cmCoreTryCompile.cxx @@ -77,7 +77,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, } const char* sourceDirectory = argv[2].c_str(); - const char* projectName = 0; + const char* projectName = CM_NULLPTR; std::string targetName; std::vector<std::string> cmakeFlags(1, "CMAKE_FLAGS"); // fake argv[0] std::vector<std::string> compileDefs; @@ -333,14 +333,43 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv, fprintf(fout, "set(CMAKE_%s_FLAGS \"${CMAKE_%s_FLAGS}" " ${COMPILE_DEFINITIONS}\")\n", li->c_str(), li->c_str()); - static std::string const cfgDefault = "DEBUG"; - std::string const cfg = - !tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault; - std::string const langFlagsCfg = "CMAKE_" + *li + "_FLAGS_" + cfg; - const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg); - fprintf( - fout, "set(%s %s)\n", langFlagsCfg.c_str(), - cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "").c_str()); + } + switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0066)) { + case cmPolicies::WARN: + if (this->Makefile->PolicyOptionalWarningEnabled( + "CMAKE_POLICY_WARNING_CMP0066")) { + std::ostringstream w; + /* clang-format off */ + w << cmPolicies::GetPolicyWarning(cmPolicies::CMP0066) << "\n" + "For compatibility with older versions of CMake, try_compile " + "is not honoring caller config-specific compiler flags " + "(e.g. CMAKE_C_FLAGS_DEBUG) in the test project." + ; + /* clang-format on */ + this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str()); + } + case cmPolicies::OLD: + // OLD behavior is to do nothing. + break; + case cmPolicies::REQUIRED_IF_USED: + case cmPolicies::REQUIRED_ALWAYS: + this->Makefile->IssueMessage( + cmake::FATAL_ERROR, + cmPolicies::GetRequiredPolicyError(cmPolicies::CMP0066)); + case cmPolicies::NEW: { + // NEW behavior is to pass config-specific compiler flags. + static std::string const cfgDefault = "DEBUG"; + std::string const cfg = + !tcConfig.empty() ? cmSystemTools::UpperCase(tcConfig) : cfgDefault; + for (std::set<std::string>::iterator li = testLangs.begin(); + li != testLangs.end(); ++li) { + std::string const langFlagsCfg = "CMAKE_" + *li + "_FLAGS_" + cfg; + const char* flagsCfg = this->Makefile->GetDefinition(langFlagsCfg); + fprintf(fout, "set(%s %s)\n", langFlagsCfg.c_str(), + cmOutputConverter::EscapeForCMake(flagsCfg ? flagsCfg : "") + .c_str()); + } + } break; } switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0056)) { case cmPolicies::WARN: diff --git a/Source/cmCreateTestSourceList.h b/Source/cmCreateTestSourceList.h index cfaca2e..2025ecd 100644 --- a/Source/cmCreateTestSourceList.h +++ b/Source/cmCreateTestSourceList.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmCreateTestSourceList; } + cmCommand* Clone() CM_OVERRIDE { return new cmCreateTestSourceList; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "create_test_sourcelist"; } + std::string GetName() const CM_OVERRIDE { return "create_test_sourcelist"; } cmTypeMacro(cmCreateTestSourceList, cmCommand); }; diff --git a/Source/cmCryptoHash.cxx b/Source/cmCryptoHash.cxx index 85049ca..8d60c1f 100644 --- a/Source/cmCryptoHash.cxx +++ b/Source/cmCryptoHash.cxx @@ -15,22 +15,22 @@ #include <cmsys/FStream.hxx> #include <cmsys/MD5.h> -cmsys::auto_ptr<cmCryptoHash> cmCryptoHash::New(const char* algo) +CM_AUTO_PTR<cmCryptoHash> cmCryptoHash::New(const char* algo) { if (strcmp(algo, "MD5") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashMD5); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashMD5); } else if (strcmp(algo, "SHA1") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA1); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA1); } else if (strcmp(algo, "SHA224") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA224); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA224); } else if (strcmp(algo, "SHA256") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA256); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA256); } else if (strcmp(algo, "SHA384") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA384); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA384); } else if (strcmp(algo, "SHA512") == 0) { - return cmsys::auto_ptr<cmCryptoHash>(new cmCryptoHashSHA512); + return CM_AUTO_PTR<cmCryptoHash>(new cmCryptoHashSHA512); } else { - return cmsys::auto_ptr<cmCryptoHash>(0); + return CM_AUTO_PTR<cmCryptoHash>(CM_NULLPTR); } } diff --git a/Source/cmCryptoHash.h b/Source/cmCryptoHash.h index a0c5eab..6aaaf93 100644 --- a/Source/cmCryptoHash.h +++ b/Source/cmCryptoHash.h @@ -14,13 +14,13 @@ #include "cmStandardIncludes.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> class cmCryptoHash { public: virtual ~cmCryptoHash() {} - static cmsys::auto_ptr<cmCryptoHash> New(const char* algo); + static CM_AUTO_PTR<cmCryptoHash> New(const char* algo); std::string HashString(const std::string& input); std::string HashFile(const std::string& file); @@ -36,12 +36,12 @@ class cmCryptoHashMD5 : public cmCryptoHash public: cmCryptoHashMD5(); - ~cmCryptoHashMD5(); + ~cmCryptoHashMD5() CM_OVERRIDE; protected: - virtual void Initialize(); - virtual void Append(unsigned char const* buf, int sz); - virtual std::string Finalize(); + void Initialize() CM_OVERRIDE; + void Append(unsigned char const* buf, int sz) CM_OVERRIDE; + std::string Finalize() CM_OVERRIDE; }; #define cmCryptoHash_SHA_CLASS_DECL(SHA) \ diff --git a/Source/cmCurl.h b/Source/cmCurl.h index eac7f13..26bf94e 100644 --- a/Source/cmCurl.h +++ b/Source/cmCurl.h @@ -16,6 +16,6 @@ #include "cm_curl.h" -std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile = 0); +std::string cmCurlSetCAInfo(::CURL* curl, const char* cafile = CM_NULLPTR); #endif diff --git a/Source/cmCustomCommand.cxx b/Source/cmCustomCommand.cxx index 4c5bd03..7533369 100644 --- a/Source/cmCustomCommand.cxx +++ b/Source/cmCustomCommand.cxx @@ -13,7 +13,7 @@ #include "cmMakefile.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> cmCustomCommand::cmCustomCommand() : Backtrace() @@ -38,7 +38,7 @@ cmCustomCommand::cmCustomCommand(cmMakefile const* mf, , Backtrace() , Comment(comment ? comment : "") , WorkingDirectory(workingDirectory ? workingDirectory : "") - , HaveComment(comment != NULL) + , HaveComment(comment != CM_NULLPTR) , EscapeAllowMakeVars(false) , EscapeOldStyle(true) { @@ -69,7 +69,7 @@ const cmCustomCommandLines& cmCustomCommand::GetCommandLines() const const char* cmCustomCommand::GetComment() const { - const char* no_comment = 0; + const char* no_comment = CM_NULLPTR; return this->HaveComment ? this->Comment.c_str() : no_comment; } diff --git a/Source/cmCustomCommandGenerator.cxx b/Source/cmCustomCommandGenerator.cxx index 99bb601..6165bcf 100644 --- a/Source/cmCustomCommandGenerator.cxx +++ b/Source/cmCustomCommandGenerator.cxx @@ -45,7 +45,7 @@ bool cmCustomCommandGenerator::UseCrossCompilingEmulator(unsigned int c) const std::string const& argv0 = this->CC.GetCommandLines()[c][0]; cmGeneratorTarget* target = this->LG->FindGeneratorTargetToUse(argv0); if (target && target->GetType() == cmState::EXECUTABLE) { - return target->GetProperty("CROSSCOMPILING_EMULATOR") != 0; + return target->GetProperty("CROSSCOMPILING_EMULATOR") != CM_NULLPTR; } return false; } @@ -66,7 +66,7 @@ std::string cmCustomCommandGenerator::GetCommand(unsigned int c) const } } - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(argv0); std::string exe = cge->Evaluate(this->LG, this->Config); return exe; @@ -145,7 +145,7 @@ std::vector<std::string> const& cmCustomCommandGenerator::GetDepends() const std::vector<std::string> depends = this->CC.GetDepends(); for (std::vector<std::string>::const_iterator i = depends.begin(); i != depends.end(); ++i) { - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = this->GE->Parse(*i); std::vector<std::string> result; cmSystemTools::ExpandListArgument(cge->Evaluate(this->LG, this->Config), result); diff --git a/Source/cmDefinePropertyCommand.h b/Source/cmDefinePropertyCommand.h index 4248bbe..9cc19c4 100644 --- a/Source/cmDefinePropertyCommand.h +++ b/Source/cmDefinePropertyCommand.h @@ -17,19 +17,19 @@ class cmDefinePropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmDefinePropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmDefinePropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "define_property"; } + std::string GetName() const CM_OVERRIDE { return "define_property"; } cmTypeMacro(cmDefinePropertyCommand, cmCommand); diff --git a/Source/cmDefinitions.cxx b/Source/cmDefinitions.cxx index 28b6677..e0fb59b 100644 --- a/Source/cmDefinitions.cxx +++ b/Source/cmDefinitions.cxx @@ -41,7 +41,7 @@ const char* cmDefinitions::Get(const std::string& key, StackIter begin, StackIter end) { Def const& def = cmDefinitions::GetInternal(key, begin, end, false); - return def.Exists ? def.c_str() : 0; + return def.Exists ? def.c_str() : CM_NULLPTR; } void cmDefinitions::Raise(const std::string& key, StackIter begin, diff --git a/Source/cmDefinitions.h b/Source/cmDefinitions.h index 7be0098..8f1813c 100644 --- a/Source/cmDefinitions.h +++ b/Source/cmDefinitions.h @@ -17,7 +17,7 @@ #include "cmLinkedTree.h" #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP #include <unordered_map> #else #include "cmsys/hash_map.hxx" @@ -92,7 +92,7 @@ private: static Def NoDef; #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, Def> MapType; #else typedef cmsys::hash_map<std::string, Def> MapType; diff --git a/Source/cmDepends.cxx b/Source/cmDepends.cxx index 5df3cc1..b25e3ce 100644 --- a/Source/cmDepends.cxx +++ b/Source/cmDepends.cxx @@ -23,7 +23,7 @@ cmDepends::cmDepends(cmLocalGenerator* lg, const char* targetDir) : CompileDirectory() , LocalGenerator(lg) , Verbose(false) - , FileComparison(0) + , FileComparison(CM_NULLPTR) , TargetDirectory(targetDir) , MaxPath(16384) , Dependee(new char[MaxPath]) @@ -140,7 +140,7 @@ bool cmDepends::CheckDependencies( // regenerated. bool okay = true; bool dependerExists = false; - DependencyVector* currentDependencies = 0; + DependencyVector* currentDependencies = CM_NULLPTR; while (internalDepends.getline(this->Dependee, this->MaxPath)) { if (this->Dependee[0] == 0 || this->Dependee[0] == '#' || @@ -182,7 +182,7 @@ bool cmDepends::CheckDependencies( bool regenerate = false; const char* dependee = this->Dependee + 1; const char* depender = this->Depender; - if (currentDependencies != 0) { + if (currentDependencies != CM_NULLPTR) { currentDependencies->push_back(dependee); } @@ -242,9 +242,9 @@ bool cmDepends::CheckDependencies( // Remove the information of this depender from the map, it needs // to be rescanned - if (currentDependencies != 0) { + if (currentDependencies != CM_NULLPTR) { validDeps.erase(this->Depender); - currentDependencies = 0; + currentDependencies = CM_NULLPTR; } // Remove the depender to be sure it is rebuilt. @@ -261,7 +261,7 @@ bool cmDepends::CheckDependencies( void cmDepends::SetIncludePathFromLanguage(const std::string& lang) { // Look for the new per "TARGET_" variant first: - const char* includePath = 0; + const char* includePath = CM_NULLPTR; std::string includePathVar = "CMAKE_"; includePathVar += lang; includePathVar += "_TARGET_INCLUDE_PATH"; diff --git a/Source/cmDepends.h b/Source/cmDepends.h index a62f8c2..0e1cbb9 100644 --- a/Source/cmDepends.h +++ b/Source/cmDepends.h @@ -29,7 +29,7 @@ class cmDepends public: /** Instances need to know the build directory name and the relative path from the build directory to the target file. */ - cmDepends(cmLocalGenerator* lg = 0, const char* targetDir = ""); + cmDepends(cmLocalGenerator* lg = CM_NULLPTR, const char* targetDir = ""); /** at what level will the compile be done from */ void SetCompileDirectory(const char* dir) { this->CompileDirectory = dir; } diff --git a/Source/cmDependsC.cxx b/Source/cmDependsC.cxx index 57e719c..18e123e 100644 --- a/Source/cmDependsC.cxx +++ b/Source/cmDependsC.cxx @@ -29,7 +29,7 @@ #define INCLUDE_REGEX_TRANSFORM_MARKER "#IncludeRegexTransform: " cmDependsC::cmDependsC() - : ValidDeps(0) + : ValidDeps(CM_NULLPTR) { } @@ -105,7 +105,7 @@ bool cmDependsC::WriteDependencies(const std::set<std::string>& sources, std::set<std::string> dependencies; bool haveDeps = false; - if (this->ValidDeps != 0) { + if (this->ValidDeps != CM_NULLPTR) { std::map<std::string, DependencyVector>::const_iterator tmpIt = this->ValidDeps->find(obj); if (tmpIt != this->ValidDeps->end()) { @@ -269,12 +269,12 @@ void cmDependsC::ReadCacheFile() } std::string line; - cmIncludeLines* cacheEntry = 0; + cmIncludeLines* cacheEntry = CM_NULLPTR; bool haveFileName = false; while (cmSystemTools::GetLineFromStream(fin, line)) { if (line.empty()) { - cacheEntry = 0; + cacheEntry = CM_NULLPTR; haveFileName = false; continue; } @@ -312,7 +312,7 @@ void cmDependsC::ReadCacheFile() } } } - } else if (cacheEntry != 0) { + } else if (cacheEntry != CM_NULLPTR) { UnscannedEntry entry; entry.FileName = line; if (cmSystemTools::GetLineFromStream(fin, line)) { diff --git a/Source/cmDependsC.h b/Source/cmDependsC.h index e830aa8..bde07b7 100644 --- a/Source/cmDependsC.h +++ b/Source/cmDependsC.h @@ -31,14 +31,13 @@ public: const std::map<std::string, DependencyVector>* validDeps); /** Virtual destructor to cleanup subclasses properly. */ - virtual ~cmDependsC(); + ~cmDependsC() CM_OVERRIDE; protected: // Implement writing/checking methods required by superclass. - virtual bool WriteDependencies(const std::set<std::string>& sources, - const std::string& obj, - std::ostream& makeDepends, - std::ostream& internalDepends); + bool WriteDependencies(const std::set<std::string>& sources, + const std::string& obj, std::ostream& makeDepends, + std::ostream& internalDepends) CM_OVERRIDE; // Method to scan a single file. void Scan(std::istream& is, const char* directory, diff --git a/Source/cmDependsFortran.cxx b/Source/cmDependsFortran.cxx index bbda688..9ea1e48 100644 --- a/Source/cmDependsFortran.cxx +++ b/Source/cmDependsFortran.cxx @@ -53,7 +53,7 @@ public: }; cmDependsFortran::cmDependsFortran() - : Internal(0) + : Internal(CM_NULLPTR) { } diff --git a/Source/cmDependsFortran.h b/Source/cmDependsFortran.h index 5ff0b6c..f4385eb 100644 --- a/Source/cmDependsFortran.h +++ b/Source/cmDependsFortran.h @@ -34,7 +34,7 @@ public: cmDependsFortran(cmLocalGenerator* lg); /** Virtual destructor to cleanup subclasses properly. */ - virtual ~cmDependsFortran(); + ~cmDependsFortran() CM_OVERRIDE; /** Callback from build system after a .mod file has been generated by a Fortran90 compiler to copy the .mod file to the @@ -48,8 +48,8 @@ public: protected: // Finalize the dependency information for the target. - virtual bool Finalize(std::ostream& makeDepends, - std::ostream& internalDepends); + bool Finalize(std::ostream& makeDepends, + std::ostream& internalDepends) CM_OVERRIDE; // Find all the modules required by the target. void LocateModules(); @@ -59,10 +59,9 @@ protected: bool FindModule(std::string const& name, std::string& module); // Implement writing/checking methods required by superclass. - virtual bool WriteDependencies(const std::set<std::string>& sources, - const std::string& file, - std::ostream& makeDepends, - std::ostream& internalDepends); + bool WriteDependencies(const std::set<std::string>& sources, + const std::string& file, std::ostream& makeDepends, + std::ostream& internalDepends) CM_OVERRIDE; // Actually write the depenencies to the streams. bool WriteDependenciesReal(const char* obj, cmFortranSourceInfo const& info, diff --git a/Source/cmDependsJava.h b/Source/cmDependsJava.h index 44723fa..5bb3039 100644 --- a/Source/cmDependsJava.h +++ b/Source/cmDependsJava.h @@ -25,17 +25,16 @@ public: cmDependsJava(); /** Virtual destructor to cleanup subclasses properly. */ - virtual ~cmDependsJava(); + ~cmDependsJava() CM_OVERRIDE; protected: // Implement writing/checking methods required by superclass. - virtual bool WriteDependencies(const std::set<std::string>& sources, - const std::string& file, - std::ostream& makeDepends, - std::ostream& internalDepends); - virtual bool CheckDependencies( + bool WriteDependencies(const std::set<std::string>& sources, + const std::string& file, std::ostream& makeDepends, + std::ostream& internalDepends) CM_OVERRIDE; + bool CheckDependencies( std::istream& internalDepends, const char* internalDependsFileName, - std::map<std::string, DependencyVector>& validDeps); + std::map<std::string, DependencyVector>& validDeps) CM_OVERRIDE; private: cmDependsJava(cmDependsJava const&); // Purposely not implemented. diff --git a/Source/cmDependsJavaParserHelper.cxx b/Source/cmDependsJavaParserHelper.cxx index 238e7a1..79c4669 100644 --- a/Source/cmDependsJavaParserHelper.cxx +++ b/Source/cmDependsJavaParserHelper.cxx @@ -59,7 +59,7 @@ void cmDependsJavaParserHelper::DeallocateParserType(char** pt) if (!*pt) { return; } - *pt = 0; + *pt = CM_NULLPTR; this->UnionsAvailable--; } @@ -160,13 +160,13 @@ void cmDependsJavaParserHelper::PrepareElement( cmDependsJavaParserHelper::ParserType* me) { // Inititalize self - me->str = 0; + me->str = CM_NULLPTR; } void cmDependsJavaParserHelper::AllocateParserType( cmDependsJavaParserHelper::ParserType* pt, const char* str, int len) { - pt->str = 0; + pt->str = CM_NULLPTR; if (len == 0) { len = (int)strlen(str); } @@ -226,7 +226,7 @@ std::vector<std::string> cmDependsJavaParserHelper::GetFilesProduced() std::vector<CurrentClass>::const_iterator it; for (it = toplevel.NestedClasses.begin(); it != toplevel.NestedClasses.end(); ++it) { - it->AddFileNamesForPrinting(&files, 0, "$"); + it->AddFileNamesForPrinting(&files, CM_NULLPTR, "$"); } return files; } @@ -326,7 +326,7 @@ void cmDependsJavaParserHelper::Error(const char* str) void cmDependsJavaParserHelper::UpdateCombine(const char* str1, const char* str2) { - if (this->CurrentCombine == "" && str1 != 0) { + if (this->CurrentCombine == "" && str1 != CM_NULLPTR) { this->CurrentCombine = str1; } this->CurrentCombine += "."; diff --git a/Source/cmDocumentation.cxx b/Source/cmDocumentation.cxx index 413dacd..919a45e 100644 --- a/Source/cmDocumentation.cxx +++ b/Source/cmDocumentation.cxx @@ -49,12 +49,12 @@ static const char* cmDocumentationStandardOptions[][2] = { { "--help-variable-list [<f>]", "List variables with help available and exit." }, { "--help-variables [<f>]", "Print cmake-variables manual and exit." }, - { 0, 0 } + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationGeneratorsHeader[][2] = { - { 0, "The following generators are available on this platform:" }, - { 0, 0 } + { CM_NULLPTR, "The following generators are available on this platform:" }, + { CM_NULLPTR, CM_NULLPTR } }; cmDocumentation::cmDocumentation() @@ -137,7 +137,7 @@ bool cmDocumentation::PrintRequestedDocumentation(std::ostream& os) this->CurrentArgument = i->Argument; // If a file name was given, use it. Otherwise, default to the // given stream. - cmsys::ofstream* fout = 0; + cmsys::ofstream* fout = CM_NULLPTR; std::ostream* s = &os; if (!i->Filename.empty()) { fout = new cmsys::ofstream(i->Filename.c_str()); @@ -420,7 +420,7 @@ void cmDocumentation::SetSections( void cmDocumentation::PrependSection(const char* name, const char* docs[][2]) { - cmDocumentationSection* sec = 0; + cmDocumentationSection* sec = CM_NULLPTR; if (this->AllSections.find(name) == this->AllSections.end()) { sec = new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str()); @@ -434,7 +434,7 @@ void cmDocumentation::PrependSection(const char* name, const char* docs[][2]) void cmDocumentation::PrependSection(const char* name, std::vector<cmDocumentationEntry>& docs) { - cmDocumentationSection* sec = 0; + cmDocumentationSection* sec = CM_NULLPTR; if (this->AllSections.find(name) == this->AllSections.end()) { sec = new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str()); @@ -447,7 +447,7 @@ void cmDocumentation::PrependSection(const char* name, void cmDocumentation::AppendSection(const char* name, const char* docs[][2]) { - cmDocumentationSection* sec = 0; + cmDocumentationSection* sec = CM_NULLPTR; if (this->AllSections.find(name) == this->AllSections.end()) { sec = new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str()); @@ -461,7 +461,7 @@ void cmDocumentation::AppendSection(const char* name, const char* docs[][2]) void cmDocumentation::AppendSection(const char* name, std::vector<cmDocumentationEntry>& docs) { - cmDocumentationSection* sec = 0; + cmDocumentationSection* sec = CM_NULLPTR; if (this->AllSections.find(name) == this->AllSections.end()) { sec = new cmDocumentationSection(name, cmSystemTools::UpperCase(name).c_str()); diff --git a/Source/cmDocumentation.h b/Source/cmDocumentation.h index dd99ca8..ac36c8b 100644 --- a/Source/cmDocumentation.h +++ b/Source/cmDocumentation.h @@ -39,7 +39,7 @@ public: * help arguments. */ bool CheckOptions(int argc, const char* const* argv, - const char* exitOpt = 0); + const char* exitOpt = CM_NULLPTR); /** * Print help requested on the command line. Call after diff --git a/Source/cmDynamicLoader.cxx b/Source/cmDynamicLoader.cxx index 7d0bbdc..4c31733f 100644 --- a/Source/cmDynamicLoader.cxx +++ b/Source/cmDynamicLoader.cxx @@ -26,7 +26,7 @@ private: static cmDynamicLoaderCache* Instance; }; -cmDynamicLoaderCache* cmDynamicLoaderCache::Instance = 0; +cmDynamicLoaderCache* cmDynamicLoaderCache::Instance = CM_NULLPTR; cmDynamicLoaderCache::~cmDynamicLoaderCache() { @@ -75,7 +75,7 @@ void cmDynamicLoaderCache::FlushCache() cmsys::DynamicLoader::CloseLibrary(it->second); } delete cmDynamicLoaderCache::Instance; - cmDynamicLoaderCache::Instance = 0; + cmDynamicLoaderCache::Instance = CM_NULLPTR; } cmDynamicLoaderCache* cmDynamicLoaderCache::GetInstance() diff --git a/Source/cmELF.cxx b/Source/cmELF.cxx index c7f8a2d..15755cb 100644 --- a/Source/cmELF.cxx +++ b/Source/cmELF.cxx @@ -13,8 +13,8 @@ #include "cmELF.h" +#include <cm_auto_ptr.hxx> #include <cmsys/FStream.hxx> -#include <cmsys/auto_ptr.hxx> // Include the ELF format information system header. #if defined(__OpenBSD__) @@ -107,7 +107,7 @@ public: }; // Construct and take ownership of the file stream object. - cmELFInternal(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin, + cmELFInternal(cmELF* external, CM_AUTO_PTR<cmsys::ifstream>& fin, ByteOrderType order) : External(external) , Stream(*fin.release()) @@ -237,24 +237,24 @@ public: typedef typename Types::tagtype tagtype; // Construct with a stream and byte swap indicator. - cmELFInternalImpl(cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin, + cmELFInternalImpl(cmELF* external, CM_AUTO_PTR<cmsys::ifstream>& fin, ByteOrderType order); // Return the number of sections as specified by the ELF header. - virtual unsigned int GetNumberOfSections() const + unsigned int GetNumberOfSections() const CM_OVERRIDE { return static_cast<unsigned int>(this->ELFHeader.e_shnum); } // Get the file position and size of a dynamic section entry. - virtual unsigned int GetDynamicEntryCount(); - virtual unsigned long GetDynamicEntryPosition(int j); + unsigned int GetDynamicEntryCount() CM_OVERRIDE; + unsigned long GetDynamicEntryPosition(int j) CM_OVERRIDE; // Lookup a string from the dynamic section with the given tag. - virtual StringEntry const* GetDynamicSectionString(unsigned int tag); + StringEntry const* GetDynamicSectionString(unsigned int tag) CM_OVERRIDE; // Print information about the ELF file. - virtual void PrintInfo(std::ostream& os) const + void PrintInfo(std::ostream& os) const CM_OVERRIDE { os << "ELF " << Types::GetName(); if (this->ByteOrder == ByteOrderMSB) { @@ -537,8 +537,9 @@ private: }; template <class Types> -cmELFInternalImpl<Types>::cmELFInternalImpl( - cmELF* external, cmsys::auto_ptr<cmsys::ifstream>& fin, ByteOrderType order) +cmELFInternalImpl<Types>::cmELFInternalImpl(cmELF* external, + CM_AUTO_PTR<cmsys::ifstream>& fin, + ByteOrderType order) : cmELFInternal(external, fin, order) { // Read the main header. @@ -672,7 +673,7 @@ cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString( if (dssi->second.Position > 0) { return &dssi->second; } - return 0; + return CM_NULLPTR; } // Create an entry for this tag. Assume it is missing until found. @@ -683,14 +684,14 @@ cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString( // Try reading the dynamic section. if (!this->LoadDynamicSection()) { - return 0; + return CM_NULLPTR; } // Get the string table referenced by the DYNAMIC section. ELF_Shdr const& sec = this->SectionHeaders[this->DynamicSectionIndex]; if (sec.sh_link >= this->SectionHeaders.size()) { this->SetErrorMessage("Section DYNAMIC has invalid string table index."); - return 0; + return CM_NULLPTR; } ELF_Shdr const& strtab = this->SectionHeaders[sec.sh_link]; @@ -705,7 +706,7 @@ cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString( if (dyn.d_un.d_val >= strtab.sh_size) { this->SetErrorMessage("Section DYNAMIC references string beyond " "the end of its string section."); - return 0; + return CM_NULLPTR; } // Seek to the position reported by the entry. @@ -734,7 +735,7 @@ cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString( if (!this->Stream) { this->SetErrorMessage("Dynamic section specifies unreadable RPATH."); se.Value = ""; - return 0; + return CM_NULLPTR; } // The value has been read successfully. Report it. @@ -745,17 +746,17 @@ cmELF::StringEntry const* cmELFInternalImpl<Types>::GetDynamicSectionString( return &se; } } - return 0; + return CM_NULLPTR; } //============================================================================ // External class implementation. cmELF::cmELF(const char* fname) - : Internal(0) + : Internal(CM_NULLPTR) { // Try to open the file. - cmsys::auto_ptr<cmsys::ifstream> fin(new cmsys::ifstream(fname)); + CM_AUTO_PTR<cmsys::ifstream> fin(new cmsys::ifstream(fname)); // Quit now if the file could not be opened. if (!fin.get() || !*fin) { @@ -879,7 +880,7 @@ cmELF::StringEntry const* cmELF::GetSOName() this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary) { return this->Internal->GetSOName(); } else { - return 0; + return CM_NULLPTR; } } @@ -890,7 +891,7 @@ cmELF::StringEntry const* cmELF::GetRPath() this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) { return this->Internal->GetRPath(); } else { - return 0; + return CM_NULLPTR; } } @@ -901,7 +902,7 @@ cmELF::StringEntry const* cmELF::GetRunPath() this->Internal->GetFileType() == cmELF::FileTypeSharedLibrary)) { return this->Internal->GetRunPath(); } else { - return 0; + return CM_NULLPTR; } } diff --git a/Source/cmElseCommand.h b/Source/cmElseCommand.h index 815825e..9acf4d8 100644 --- a/Source/cmElseCommand.h +++ b/Source/cmElseCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmElseCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmElseCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "else"; } + std::string GetName() const CM_OVERRIDE { return "else"; } cmTypeMacro(cmElseCommand, cmCommand); }; diff --git a/Source/cmElseIfCommand.h b/Source/cmElseIfCommand.h index d0ffa5d..19c1885 100644 --- a/Source/cmElseIfCommand.h +++ b/Source/cmElseIfCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmElseIfCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmElseIfCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "elseif"; } + std::string GetName() const CM_OVERRIDE { return "elseif"; } cmTypeMacro(cmElseIfCommand, cmCommand); }; diff --git a/Source/cmEnableLanguageCommand.h b/Source/cmEnableLanguageCommand.h index 657e4e5..31b6095 100644 --- a/Source/cmEnableLanguageCommand.h +++ b/Source/cmEnableLanguageCommand.h @@ -28,19 +28,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEnableLanguageCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEnableLanguageCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "enable_language"; } + std::string GetName() const CM_OVERRIDE { return "enable_language"; } cmTypeMacro(cmEnableLanguageCommand, cmCommand); }; diff --git a/Source/cmEnableTestingCommand.h b/Source/cmEnableTestingCommand.h index a518f18..8c8ffbf 100644 --- a/Source/cmEnableTestingCommand.h +++ b/Source/cmEnableTestingCommand.h @@ -33,19 +33,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEnableTestingCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEnableTestingCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "enable_testing"; } + std::string GetName() const CM_OVERRIDE { return "enable_testing"; } cmTypeMacro(cmEnableTestingCommand, cmCommand); }; diff --git a/Source/cmEndForEachCommand.h b/Source/cmEndForEachCommand.h index ebc794f..b2c47b2 100644 --- a/Source/cmEndForEachCommand.h +++ b/Source/cmEndForEachCommand.h @@ -25,20 +25,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEndForEachCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEndForEachCommand; } /** * Override cmCommand::InvokeInitialPass to get arguments before * expansion. */ - virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&, - cmExecutionStatus&); + bool InvokeInitialPass(std::vector<cmListFileArgument> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -46,12 +47,12 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "endforeach"; } + std::string GetName() const CM_OVERRIDE { return "endforeach"; } cmTypeMacro(cmEndForEachCommand, cmCommand); }; diff --git a/Source/cmEndFunctionCommand.h b/Source/cmEndFunctionCommand.h index b69dec0..856fdc5 100644 --- a/Source/cmEndFunctionCommand.h +++ b/Source/cmEndFunctionCommand.h @@ -25,20 +25,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEndFunctionCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEndFunctionCommand; } /** * Override cmCommand::InvokeInitialPass to get arguments before * expansion. */ - virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&, - cmExecutionStatus&); + bool InvokeInitialPass(std::vector<cmListFileArgument> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -46,12 +47,12 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "endfunction"; } + std::string GetName() const CM_OVERRIDE { return "endfunction"; } cmTypeMacro(cmEndFunctionCommand, cmCommand); }; diff --git a/Source/cmEndIfCommand.h b/Source/cmEndIfCommand.h index 457dfd3..13cf6f6 100644 --- a/Source/cmEndIfCommand.h +++ b/Source/cmEndIfCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEndIfCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEndIfCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "endif"; } + std::string GetName() const CM_OVERRIDE { return "endif"; } cmTypeMacro(cmEndIfCommand, cmCommand); }; diff --git a/Source/cmEndMacroCommand.h b/Source/cmEndMacroCommand.h index 615e8dc..e176eaf 100644 --- a/Source/cmEndMacroCommand.h +++ b/Source/cmEndMacroCommand.h @@ -25,20 +25,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEndMacroCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEndMacroCommand; } /** * Override cmCommand::InvokeInitialPass to get arguments before * expansion. */ - virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const&, - cmExecutionStatus&); + bool InvokeInitialPass(std::vector<cmListFileArgument> const&, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -46,12 +47,12 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "endmacro"; } + std::string GetName() const CM_OVERRIDE { return "endmacro"; } cmTypeMacro(cmEndMacroCommand, cmCommand); }; diff --git a/Source/cmEndWhileCommand.h b/Source/cmEndWhileCommand.h index 5eda7af..6b72514 100644 --- a/Source/cmEndWhileCommand.h +++ b/Source/cmEndWhileCommand.h @@ -25,20 +25,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmEndWhileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmEndWhileCommand; } /** * Override cmCommand::InvokeInitialPass to get arguments before * expansion. */ - virtual bool InvokeInitialPass(std::vector<cmListFileArgument> const& args, - cmExecutionStatus& status); + bool InvokeInitialPass(std::vector<cmListFileArgument> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -46,12 +47,12 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "endwhile"; } + std::string GetName() const CM_OVERRIDE { return "endwhile"; } cmTypeMacro(cmEndWhileCommand, cmCommand); }; diff --git a/Source/cmExecProgramCommand.cxx b/Source/cmExecProgramCommand.cxx index f3f8c2f..58bbc31 100644 --- a/Source/cmExecProgramCommand.cxx +++ b/Source/cmExecProgramCommand.cxx @@ -90,7 +90,7 @@ bool cmExecProgramCommand::InitialPass(std::vector<std::string> const& args, args[1].c_str(), verbose); } else { result = cmExecProgramCommand::RunCommand(command.c_str(), output, retVal, - 0, verbose); + CM_NULLPTR, verbose); } if (!result) { retVal = -1; @@ -209,7 +209,7 @@ bool cmExecProgramCommand::RunCommand(const char* command, std::string& output, } fflush(stdout); fflush(stderr); - const char* cmd[] = { "/bin/sh", "-c", command, 0 }; + const char* cmd[] = { "/bin/sh", "-c", command, CM_NULLPTR }; cmsysProcess_SetCommand(cp, cmd); #endif @@ -219,7 +219,7 @@ bool cmExecProgramCommand::RunCommand(const char* command, std::string& output, int length; char* data; int p; - while ((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) { + while ((p = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR), p)) { if (p == cmsysProcess_Pipe_STDOUT || p == cmsysProcess_Pipe_STDERR) { if (verbose) { cmSystemTools::Stdout(data, length); @@ -229,7 +229,7 @@ bool cmExecProgramCommand::RunCommand(const char* command, std::string& output, } // All output has been read. Wait for the process to exit. - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); // Check the result of running the process. std::string msg; diff --git a/Source/cmExecProgramCommand.h b/Source/cmExecProgramCommand.h index e6e76d2..7cd4f9f 100644 --- a/Source/cmExecProgramCommand.h +++ b/Source/cmExecProgramCommand.h @@ -27,30 +27,31 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmExecProgramCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmExecProgramCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "exec_program"; } + std::string GetName() const CM_OVERRIDE { return "exec_program"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmExecProgramCommand, cmCommand); private: static bool RunCommand(const char* command, std::string& output, int& retVal, - const char* directory = 0, bool verbose = true); + const char* directory = CM_NULLPTR, + bool verbose = true); }; #endif diff --git a/Source/cmExecuteProcessCommand.cxx b/Source/cmExecuteProcessCommand.cxx index 575cdc3..d97b25f 100644 --- a/Source/cmExecuteProcessCommand.cxx +++ b/Source/cmExecuteProcessCommand.cxx @@ -161,7 +161,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args, return false; } else { // Add the null terminating pointer to the command argument list. - cmds[i].push_back(0); + cmds[i].push_back(CM_NULLPTR); } } @@ -228,7 +228,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args, int length; char* data; int p; - while ((p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) { + while ((p = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR), p)) { // Put the output in the right place. if (p == cmsysProcess_Pipe_STDOUT && !output_quiet) { if (output_variable.empty()) { @@ -246,7 +246,7 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args, } // All output has been read. Wait for the process to exit. - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); // Fix the text in the output strings. cmExecuteProcessCommandFixText(tempOutput, output_strip_trailing_whitespace); diff --git a/Source/cmExecuteProcessCommand.h b/Source/cmExecuteProcessCommand.h index a89e705..61687ef 100644 --- a/Source/cmExecuteProcessCommand.h +++ b/Source/cmExecuteProcessCommand.h @@ -26,24 +26,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmExecuteProcessCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmExecuteProcessCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "execute_process"; } + std::string GetName() const CM_OVERRIDE { return "execute_process"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmExecuteProcessCommand, cmCommand); }; diff --git a/Source/cmExportBuildFileGenerator.cxx b/Source/cmExportBuildFileGenerator.cxx index 8ca7a11..a53d285 100644 --- a/Source/cmExportBuildFileGenerator.cxx +++ b/Source/cmExportBuildFileGenerator.cxx @@ -18,8 +18,8 @@ cmExportBuildFileGenerator::cmExportBuildFileGenerator() { - this->LG = 0; - this->ExportSet = 0; + this->LG = CM_NULLPTR; + this->ExportSet = CM_NULLPTR; } void cmExportBuildFileGenerator::Compute(cmLocalGenerator* lg) diff --git a/Source/cmExportBuildFileGenerator.h b/Source/cmExportBuildFileGenerator.h index be3c70a..417e8c9 100644 --- a/Source/cmExportBuildFileGenerator.h +++ b/Source/cmExportBuildFileGenerator.h @@ -50,14 +50,14 @@ public: protected: // Implement virtual methods from the superclass. - virtual bool GenerateMainFile(std::ostream& os); - virtual void GenerateImportTargetsConfig( + bool GenerateMainFile(std::ostream& os) CM_OVERRIDE; + void GenerateImportTargetsConfig( std::ostream& os, const std::string& config, std::string const& suffix, - std::vector<std::string>& missingTargets); - virtual void HandleMissingTarget(std::string& link_libs, - std::vector<std::string>& missingTargets, - cmGeneratorTarget* depender, - cmGeneratorTarget* dependee); + std::vector<std::string>& missingTargets) CM_OVERRIDE; + void HandleMissingTarget(std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) CM_OVERRIDE; void ComplainAboutMissingTarget(cmGeneratorTarget* depender, cmGeneratorTarget* dependee, @@ -70,7 +70,7 @@ protected: ImportPropertyMap& properties); std::string InstallNameDir(cmGeneratorTarget* target, - const std::string& config); + const std::string& config) CM_OVERRIDE; std::vector<std::string> FindNamespaces(cmGlobalGenerator* gg, const std::string& name); diff --git a/Source/cmExportCommand.cxx b/Source/cmExportCommand.cxx index a0e7e45..3cb575e 100644 --- a/Source/cmExportCommand.cxx +++ b/Source/cmExportCommand.cxx @@ -35,7 +35,7 @@ cmExportCommand::cmExportCommand() , Filename(&Helper, "FILE", &ArgumentGroup) , ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup) { - this->ExportSet = 0; + this->ExportSet = CM_NULLPTR; } // cmExportCommand @@ -50,10 +50,10 @@ bool cmExportCommand::InitialPass(std::vector<std::string> const& args, if (args[0] == "PACKAGE") { return this->HandlePackage(args); } else if (args[0] == "EXPORT") { - this->ExportSetName.Follows(0); + this->ExportSetName.Follows(CM_NULLPTR); this->ArgumentGroup.Follows(&this->ExportSetName); } else { - this->Targets.Follows(0); + this->Targets.Follows(CM_NULLPTR); this->ArgumentGroup.Follows(&this->Targets); } diff --git a/Source/cmExportCommand.h b/Source/cmExportCommand.h index a71393a..0a149af 100644 --- a/Source/cmExportCommand.h +++ b/Source/cmExportCommand.h @@ -30,19 +30,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmExportCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmExportCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "export"; } + std::string GetName() const CM_OVERRIDE { return "export"; } cmTypeMacro(cmExportCommand, cmCommand); diff --git a/Source/cmExportFileGenerator.cxx b/Source/cmExportFileGenerator.cxx index 736c7da..d93e406 100644 --- a/Source/cmExportFileGenerator.cxx +++ b/Source/cmExportFileGenerator.cxx @@ -25,8 +25,8 @@ #include "cmVersion.h" #include <assert.h> +#include <cm_auto_ptr.hxx> #include <cmsys/FStream.hxx> -#include <cmsys/auto_ptr.hxx> static std::string cmExportFileGeneratorEscape(std::string const& str) { @@ -69,15 +69,15 @@ const char* cmExportFileGenerator::GetMainExportFileName() const bool cmExportFileGenerator::GenerateImportFile() { // Open the output file to generate it. - cmsys::auto_ptr<cmsys::ofstream> foutPtr; + CM_AUTO_PTR<cmsys::ofstream> foutPtr; if (this->AppendMode) { // Open for append. - cmsys::auto_ptr<cmsys::ofstream> ap( + CM_AUTO_PTR<cmsys::ofstream> ap( new cmsys::ofstream(this->MainImportFile.c_str(), std::ios::app)); foutPtr = ap; } else { // Generate atomically and with copy-if-different. - cmsys::auto_ptr<cmGeneratedFileStream> ap( + CM_AUTO_PTR<cmGeneratedFileStream> ap( new cmGeneratedFileStream(this->MainImportFile.c_str(), true)); ap->SetCopyIfDifferent(true); foutPtr = ap; @@ -393,7 +393,7 @@ void cmExportFileGenerator::PopulateIncludeDirectoriesInterface( std::string dirs = cmGeneratorExpression::Preprocess( tei->InterfaceIncludeDirectories, preprocessRule, true); this->ReplaceInstallPrefix(dirs); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(dirs); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(dirs); std::string exportDirs = cge->Evaluate(target->GetLocalGenerator(), "", false, target); diff --git a/Source/cmExportInstallFileGenerator.h b/Source/cmExportInstallFileGenerator.h index 723b6e5..68960db 100644 --- a/Source/cmExportInstallFileGenerator.h +++ b/Source/cmExportInstallFileGenerator.h @@ -52,16 +52,16 @@ public: protected: // Implement virtual methods from the superclass. - virtual bool GenerateMainFile(std::ostream& os); - virtual void GenerateImportTargetsConfig( + bool GenerateMainFile(std::ostream& os) CM_OVERRIDE; + void GenerateImportTargetsConfig( std::ostream& os, const std::string& config, std::string const& suffix, - std::vector<std::string>& missingTargets); - virtual void HandleMissingTarget(std::string& link_libs, - std::vector<std::string>& missingTargets, - cmGeneratorTarget* depender, - cmGeneratorTarget* dependee); + std::vector<std::string>& missingTargets) CM_OVERRIDE; + void HandleMissingTarget(std::string& link_libs, + std::vector<std::string>& missingTargets, + cmGeneratorTarget* depender, + cmGeneratorTarget* dependee) CM_OVERRIDE; - virtual void ReplaceInstallPrefix(std::string& input); + void ReplaceInstallPrefix(std::string& input) CM_OVERRIDE; void ComplainAboutMissingTarget(cmGeneratorTarget* depender, cmGeneratorTarget* dependee, @@ -82,7 +82,7 @@ protected: std::set<std::string>& importedLocations); std::string InstallNameDir(cmGeneratorTarget* target, - const std::string& config); + const std::string& config) CM_OVERRIDE; cmInstallExportGenerator* IEGen; diff --git a/Source/cmExportLibraryDependenciesCommand.cxx b/Source/cmExportLibraryDependenciesCommand.cxx index ab43aa8..c8272cb 100644 --- a/Source/cmExportLibraryDependenciesCommand.cxx +++ b/Source/cmExportLibraryDependenciesCommand.cxx @@ -16,7 +16,7 @@ #include "cmVersion.h" #include "cmake.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> bool cmExportLibraryDependenciesCommand::InitialPass( std::vector<std::string> const& args, cmExecutionStatus&) @@ -53,13 +53,13 @@ void cmExportLibraryDependenciesCommand::FinalPass() void cmExportLibraryDependenciesCommand::ConstFinalPass() const { // Use copy-if-different if not appending. - cmsys::auto_ptr<cmsys::ofstream> foutPtr; + CM_AUTO_PTR<cmsys::ofstream> foutPtr; if (this->Append) { - cmsys::auto_ptr<cmsys::ofstream> ap( + CM_AUTO_PTR<cmsys::ofstream> ap( new cmsys::ofstream(this->Filename.c_str(), std::ios::app)); foutPtr = ap; } else { - cmsys::auto_ptr<cmGeneratedFileStream> ap( + CM_AUTO_PTR<cmGeneratedFileStream> ap( new cmGeneratedFileStream(this->Filename.c_str(), true)); ap->SetCopyIfDifferent(true); foutPtr = ap; diff --git a/Source/cmExportLibraryDependenciesCommand.h b/Source/cmExportLibraryDependenciesCommand.h index 3fb3565..4b3dc92 100644 --- a/Source/cmExportLibraryDependenciesCommand.h +++ b/Source/cmExportLibraryDependenciesCommand.h @@ -18,13 +18,19 @@ class cmExportLibraryDependenciesCommand : public cmCommand { public: cmTypeMacro(cmExportLibraryDependenciesCommand, cmCommand); - virtual cmCommand* Clone() { return new cmExportLibraryDependenciesCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "export_library_dependencies"; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmExportLibraryDependenciesCommand; + } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE + { + return "export_library_dependencies"; + } - virtual void FinalPass(); - virtual bool HasFinalPass() const { return true; } + void FinalPass() CM_OVERRIDE; + bool HasFinalPass() const CM_OVERRIDE { return true; } private: std::string Filename; diff --git a/Source/cmExportTryCompileFileGenerator.cxx b/Source/cmExportTryCompileFileGenerator.cxx index 5a826f2..2916e6b 100644 --- a/Source/cmExportTryCompileFileGenerator.cxx +++ b/Source/cmExportTryCompileFileGenerator.cxx @@ -63,9 +63,10 @@ std::string cmExportTryCompileFileGenerator::FindTargets( cmGeneratorExpression ge; - cmGeneratorExpressionDAGChecker dagChecker(tgt->GetName(), propName, 0, 0); + cmGeneratorExpressionDAGChecker dagChecker(tgt->GetName(), propName, + CM_NULLPTR, CM_NULLPTR); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cmTarget dummyHead; dummyHead.SetType(cmState::EXECUTABLE, "try_compile_dummy_exe"); diff --git a/Source/cmExportTryCompileFileGenerator.h b/Source/cmExportTryCompileFileGenerator.h index 26f4db1..1d13711 100644 --- a/Source/cmExportTryCompileFileGenerator.h +++ b/Source/cmExportTryCompileFileGenerator.h @@ -28,15 +28,15 @@ public: void SetConfig(const std::string& config) { this->Config = config; } protected: // Implement virtual methods from the superclass. - virtual bool GenerateMainFile(std::ostream& os); + bool GenerateMainFile(std::ostream& os) CM_OVERRIDE; - virtual void GenerateImportTargetsConfig(std::ostream&, const std::string&, - std::string const&, - std::vector<std::string>&) + void GenerateImportTargetsConfig(std::ostream&, const std::string&, + std::string const&, + std::vector<std::string>&) CM_OVERRIDE { } - virtual void HandleMissingTarget(std::string&, std::vector<std::string>&, - cmGeneratorTarget*, cmGeneratorTarget*) + void HandleMissingTarget(std::string&, std::vector<std::string>&, + cmGeneratorTarget*, cmGeneratorTarget*) CM_OVERRIDE { } @@ -45,7 +45,7 @@ protected: std::set<const cmGeneratorTarget*>& emitted); std::string InstallNameDir(cmGeneratorTarget* target, - const std::string& config); + const std::string& config) CM_OVERRIDE; private: std::string FindTargets(const std::string& prop, diff --git a/Source/cmExprParserHelper.cxx b/Source/cmExprParserHelper.cxx index 2ba9b8d..0771a4e 100644 --- a/Source/cmExprParserHelper.cxx +++ b/Source/cmExprParserHelper.cxx @@ -21,7 +21,7 @@ int cmExpr_yyparse(yyscan_t yyscanner); cmExprParserHelper::cmExprParserHelper() { this->FileLine = -1; - this->FileName = 0; + this->FileName = CM_NULLPTR; } cmExprParserHelper::~cmExprParserHelper() diff --git a/Source/cmExtraCodeBlocksGenerator.cxx b/Source/cmExtraCodeBlocksGenerator.cxx index dee666b..fbfbccc 100644 --- a/Source/cmExtraCodeBlocksGenerator.cxx +++ b/Source/cmExtraCodeBlocksGenerator.cxx @@ -289,8 +289,8 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile( xml.StartElement("Build"); - this->AppendTarget(xml, "all", 0, make.c_str(), lgs[0], compiler.c_str(), - makeArgs); + this->AppendTarget(xml, "all", CM_NULLPTR, make.c_str(), lgs[0], + compiler.c_str(), makeArgs); // add all executable and library targets and some of the GLOBAL // and UTILITY targets @@ -306,7 +306,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile( // not from the subdirs if (strcmp((*lg)->GetCurrentBinaryDirectory(), (*lg)->GetBinaryDirectory()) == 0) { - this->AppendTarget(xml, targetName, 0, make.c_str(), *lg, + this->AppendTarget(xml, targetName, CM_NULLPTR, make.c_str(), *lg, compiler.c_str(), makeArgs); } } break; @@ -322,7 +322,7 @@ void cmExtraCodeBlocksGenerator::CreateNewProjectFile( break; } - this->AppendTarget(xml, targetName, 0, make.c_str(), *lg, + this->AppendTarget(xml, targetName, CM_NULLPTR, make.c_str(), *lg, compiler.c_str(), makeArgs); break; case cmState::EXECUTABLE: @@ -515,7 +515,7 @@ void cmExtraCodeBlocksGenerator::AppendTarget( xml.StartElement("Target"); xml.Attribute("title", targetName); - if (target != 0) { + if (target != CM_NULLPTR) { int cbTargetType = this->GetCBTargetType(target); std::string workingDir = lg->GetCurrentBinaryDirectory(); if (target->GetType() == cmState::EXECUTABLE) { @@ -523,12 +523,12 @@ void cmExtraCodeBlocksGenerator::AppendTarget( // set the working directory to this dir. const char* runtimeOutputDir = makefile->GetDefinition("CMAKE_RUNTIME_OUTPUT_DIRECTORY"); - if (runtimeOutputDir != 0) { + if (runtimeOutputDir != CM_NULLPTR) { workingDir = runtimeOutputDir; } else { const char* executableOutputDir = makefile->GetDefinition("EXECUTABLE_OUTPUT_PATH"); - if (executableOutputDir != 0) { + if (executableOutputDir != CM_NULLPTR) { workingDir = executableOutputDir; } } diff --git a/Source/cmExtraCodeBlocksGenerator.h b/Source/cmExtraCodeBlocksGenerator.h index fe4f513..31ea500 100644 --- a/Source/cmExtraCodeBlocksGenerator.h +++ b/Source/cmExtraCodeBlocksGenerator.h @@ -28,7 +28,7 @@ class cmExtraCodeBlocksGenerator : public cmExternalMakefileProjectGenerator public: cmExtraCodeBlocksGenerator(); - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmExtraCodeBlocksGenerator::GetActualName(); } @@ -38,10 +38,10 @@ public: return new cmExtraCodeBlocksGenerator; } /** Get the documentation entry for this generator. */ - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; private: struct CbpUnit diff --git a/Source/cmExtraCodeLiteGenerator.h b/Source/cmExtraCodeLiteGenerator.h index 01ff31f..f2ee85c 100644 --- a/Source/cmExtraCodeLiteGenerator.h +++ b/Source/cmExtraCodeLiteGenerator.h @@ -36,7 +36,7 @@ protected: public: cmExtraCodeLiteGenerator(); - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmExtraCodeLiteGenerator::GetActualName(); } @@ -46,10 +46,10 @@ public: return new cmExtraCodeLiteGenerator; } /** Get the documentation entry for this generator. */ - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs); void CreateNewProjectFile(const std::vector<cmLocalGenerator*>& lgs, diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx index f964b97..16cb082 100644 --- a/Source/cmExtraEclipseCDT4Generator.cxx +++ b/Source/cmExtraEclipseCDT4Generator.cxx @@ -217,17 +217,17 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(std::ostream& out, // now we have both, decide which one to use std::string valueToUse; - if (envVarValue == 0 && cacheValue == 0) { + if (envVarValue == CM_NULLPTR && cacheValue == CM_NULLPTR) { // nothing known, do nothing valueToUse = ""; - } else if (envVarValue != 0 && cacheValue == 0) { + } else if (envVarValue != CM_NULLPTR && cacheValue == CM_NULLPTR) { // The variable is in the env, but not in the cache. Use it and put it // in the cache valueToUse = envVarValue; mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(), cacheEntryName.c_str(), cmState::STRING, true); mf->GetCMakeInstance()->SaveCache(lg->GetBinaryDirectory()); - } else if (envVarValue == 0 && cacheValue != 0) { + } else if (envVarValue == CM_NULLPTR && cacheValue != CM_NULLPTR) { // It is already in the cache, but not in the env, so use it from the cache valueToUse = cacheValue; } else { diff --git a/Source/cmExtraEclipseCDT4Generator.h b/Source/cmExtraEclipseCDT4Generator.h index 0cef071..0400ad5 100644 --- a/Source/cmExtraEclipseCDT4Generator.h +++ b/Source/cmExtraEclipseCDT4Generator.h @@ -40,19 +40,19 @@ public: return new cmExtraEclipseCDT4Generator; } - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmExtraEclipseCDT4Generator::GetActualName(); } static std::string GetActualName() { return "Eclipse CDT4"; } - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; - virtual void EnableLanguage(std::vector<std::string> const& languages, - cmMakefile*, bool optional); + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; + void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*, + bool optional) CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; private: // create .project file in the source tree @@ -82,7 +82,7 @@ private: const std::string& make, const std::string& makeArguments, const std::string& path, const char* prefix = "", - const char* makeTarget = NULL); + const char* makeTarget = CM_NULLPTR); static void AppendScannerProfile( cmXMLWriter& xml, const std::string& profileID, bool openActionEnabled, const std::string& openActionFilePath, bool pParserEnabled, diff --git a/Source/cmExtraKateGenerator.cxx b/Source/cmExtraKateGenerator.cxx index 02159dd..b757a49 100644 --- a/Source/cmExtraKateGenerator.cxx +++ b/Source/cmExtraKateGenerator.cxx @@ -137,9 +137,9 @@ void cmExtraKateGenerator::WriteTargets(const cmLocalGenerator* lg, if (targetName == "edit_cache") { const char* editCommand = (*it)->GetMakefile()->GetDefinition("CMAKE_EDIT_COMMAND"); - if (editCommand == 0) { + if (editCommand == CM_NULLPTR) { insertTarget = false; - } else if (strstr(editCommand, "ccmake") != NULL) { + } else if (strstr(editCommand, "ccmake") != CM_NULLPTR) { insertTarget = false; } } diff --git a/Source/cmExtraKateGenerator.h b/Source/cmExtraKateGenerator.h index 71e88a9..410d552 100644 --- a/Source/cmExtraKateGenerator.h +++ b/Source/cmExtraKateGenerator.h @@ -26,7 +26,7 @@ class cmExtraKateGenerator : public cmExternalMakefileProjectGenerator public: cmExtraKateGenerator(); - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmExtraKateGenerator::GetActualName(); } @@ -36,10 +36,10 @@ public: return new cmExtraKateGenerator; } /** Get the documentation entry for this generator. */ - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; private: void CreateKateProjectFile(const cmLocalGenerator* lg) const; diff --git a/Source/cmExtraSublimeTextGenerator.cxx b/Source/cmExtraSublimeTextGenerator.cxx index 2b9f64f..c166e26 100644 --- a/Source/cmExtraSublimeTextGenerator.cxx +++ b/Source/cmExtraSublimeTextGenerator.cxx @@ -134,9 +134,9 @@ void cmExtraSublimeTextGenerator::AppendAllTargets( std::string make = mf->GetRequiredDefinition("CMAKE_MAKE_PROGRAM"); std::string compiler = ""; if (!lgs.empty()) { - this->AppendTarget(fout, "all", lgs[0], 0, make.c_str(), mf, + this->AppendTarget(fout, "all", lgs[0], CM_NULLPTR, make.c_str(), mf, compiler.c_str(), sourceFileFlags, true); - this->AppendTarget(fout, "clean", lgs[0], 0, make.c_str(), mf, + this->AppendTarget(fout, "clean", lgs[0], CM_NULLPTR, make.c_str(), mf, compiler.c_str(), sourceFileFlags, false); } @@ -155,7 +155,7 @@ void cmExtraSublimeTextGenerator::AppendAllTargets( // not from the subdirs if (strcmp((*lg)->GetCurrentBinaryDirectory(), (*lg)->GetBinaryDirectory()) == 0) { - this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), + this->AppendTarget(fout, targetName, *lg, CM_NULLPTR, make.c_str(), makefile, compiler.c_str(), sourceFileFlags, false); } @@ -172,8 +172,9 @@ void cmExtraSublimeTextGenerator::AppendAllTargets( break; } - this->AppendTarget(fout, targetName, *lg, 0, make.c_str(), makefile, - compiler.c_str(), sourceFileFlags, false); + this->AppendTarget(fout, targetName, *lg, CM_NULLPTR, make.c_str(), + makefile, compiler.c_str(), sourceFileFlags, + false); break; case cmState::EXECUTABLE: case cmState::STATIC_LIBRARY: @@ -204,7 +205,7 @@ void cmExtraSublimeTextGenerator::AppendTarget( MapSourceFileFlags& sourceFileFlags, bool firstTarget) { - if (target != 0) { + if (target != CM_NULLPTR) { std::vector<cmSourceFile*> sourceFiles; target->GetSourceFiles(sourceFiles, makefile->GetSafeDefinition("CMAKE_BUILD_TYPE")); diff --git a/Source/cmExtraSublimeTextGenerator.h b/Source/cmExtraSublimeTextGenerator.h index 6efec7a..26dd138 100644 --- a/Source/cmExtraSublimeTextGenerator.h +++ b/Source/cmExtraSublimeTextGenerator.h @@ -30,7 +30,7 @@ public: typedef std::map<std::string, std::vector<std::string> > MapSourceFileFlags; cmExtraSublimeTextGenerator(); - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmExtraSublimeTextGenerator::GetActualName(); } @@ -40,10 +40,10 @@ public: return new cmExtraSublimeTextGenerator; } /** Get the documentation entry for this generator. */ - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; private: void CreateProjectFile(const std::vector<cmLocalGenerator*>& lgs); diff --git a/Source/cmFLTKWrapUICommand.cxx b/Source/cmFLTKWrapUICommand.cxx index ebd6223..03ee31e 100644 --- a/Source/cmFLTKWrapUICommand.cxx +++ b/Source/cmFLTKWrapUICommand.cxx @@ -73,8 +73,8 @@ bool cmFLTKWrapUICommand::InitialPass(std::vector<std::string> const& args, // Add command for generating the .h and .cxx files std::string no_main_dependency = ""; - const char* no_comment = 0; - const char* no_working_dir = 0; + const char* no_comment = CM_NULLPTR; + const char* no_working_dir = CM_NULLPTR; this->Makefile->AddCustomCommandToOutput( cxxres, depends, no_main_dependency, commandLines, no_comment, no_working_dir); diff --git a/Source/cmFLTKWrapUICommand.h b/Source/cmFLTKWrapUICommand.h index 2e60051..72b468e 100644 --- a/Source/cmFLTKWrapUICommand.h +++ b/Source/cmFLTKWrapUICommand.h @@ -28,14 +28,14 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFLTKWrapUICommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFLTKWrapUICommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This is called at the end after all the information @@ -43,13 +43,13 @@ public: * not implement this method. At this point, reading and * writing to the cache can be done. */ - virtual void FinalPass(); - virtual bool HasFinalPass() const { return true; } + void FinalPass() CM_OVERRIDE; + bool HasFinalPass() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "fltk_wrap_ui"; } + std::string GetName() const CM_OVERRIDE { return "fltk_wrap_ui"; } private: /** diff --git a/Source/cmFileCommand.cxx b/Source/cmFileCommand.cxx index 6abc238..5a1238b 100644 --- a/Source/cmFileCommand.cxx +++ b/Source/cmFileCommand.cxx @@ -34,12 +34,12 @@ // include sys/stat.h after sys/types.h #include <sys/stat.h> +#include <cm_auto_ptr.hxx> #include <cmsys/Directory.hxx> #include <cmsys/Encoding.hxx> #include <cmsys/FStream.hxx> #include <cmsys/Glob.hxx> #include <cmsys/RegularExpression.hxx> -#include <cmsys/auto_ptr.hxx> // Table of permissions flags. #if defined(_WIN32) && !defined(__CYGWIN__) @@ -231,17 +231,17 @@ bool cmFileCommand::HandleReadCommand(std::vector<std::string> const& args) cmCommandArgumentGroup group; cmCAString readArg(&argHelper, "READ"); - cmCAString fileNameArg(&argHelper, 0); - cmCAString resultArg(&argHelper, 0); + cmCAString fileNameArg(&argHelper, CM_NULLPTR); + cmCAString resultArg(&argHelper, CM_NULLPTR); cmCAString offsetArg(&argHelper, "OFFSET", &group); cmCAString limitArg(&argHelper, "LIMIT", &group); cmCAEnabler hexOutputArg(&argHelper, "HEX", &group); - readArg.Follows(0); + readArg.Follows(CM_NULLPTR); fileNameArg.Follows(&readArg); resultArg.Follows(&fileNameArg); group.Follows(&resultArg); - argHelper.Parse(&args, 0); + argHelper.Parse(&args, CM_NULLPTR); std::string fileName = fileNameArg.GetString(); if (!cmsys::SystemTools::FileIsFullPath(fileName.c_str())) { @@ -330,7 +330,7 @@ bool cmFileCommand::HandleHashCommand(std::vector<std::string> const& args) return false; } - cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); + CM_AUTO_PTR<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); if (hash.get()) { std::string out = hash->HashFile(args[1]); if (!out.empty()) { @@ -901,9 +901,9 @@ bool cmFileCommand::HandleDifferentCommand( */ // Evaluate arguments. - const char* file_lhs = 0; - const char* file_rhs = 0; - const char* var = 0; + const char* file_lhs = CM_NULLPTR; + const char* file_rhs = CM_NULLPTR; + const char* var = CM_NULLPTR; enum Doing { DoingNone, @@ -958,7 +958,7 @@ struct cmFileCopier , MatchlessFiles(true) , FilePermissions(0) , DirPermissions(0) - , CurrentMatchRule(0) + , CurrentMatchRule(CM_NULLPTR) , UseGivenPermissionsFile(false) , UseGivenPermissionsDir(false) , UseSourcePermissions(true) @@ -1615,7 +1615,7 @@ struct cmFileInstaller : public cmFileCopier this->Manifest = this->Makefile->GetSafeDefinition("CMAKE_INSTALL_MANIFEST_FILES"); } - ~cmFileInstaller() + ~cmFileInstaller() CM_OVERRIDE { // Save the updated install manifest. this->Makefile->AddDefinition("CMAKE_INSTALL_MANIFEST_FILES", @@ -1640,12 +1640,12 @@ protected: this->Manifest += file.substr(this->DestDirLength); } - virtual std::string const& ToName(std::string const& fromName) + std::string const& ToName(std::string const& fromName) CM_OVERRIDE { return this->Rename.empty() ? fromName : this->Rename; } - virtual void ReportCopy(const char* toFile, Type type, bool copy) + void ReportCopy(const char* toFile, Type type, bool copy) CM_OVERRIDE { if (!this->MessageNever && (copy || !this->MessageLazy)) { std::string message = (copy ? "Installing: " : "Up-to-date: "); @@ -1657,11 +1657,11 @@ protected: this->ManifestAppend(toFile); } } - virtual bool ReportMissing(const char* fromFile) + bool ReportMissing(const char* fromFile) CM_OVERRIDE { return (this->Optional || this->cmFileCopier::ReportMissing(fromFile)); } - virtual bool Install(const char* fromFile, const char* toFile) + bool Install(const char* fromFile, const char* toFile) CM_OVERRIDE { // Support installing from empty source to make a directory. if (this->InstallType == cmInstallType_DIRECTORY && !*fromFile) { @@ -1670,16 +1670,16 @@ protected: return this->cmFileCopier::Install(fromFile, toFile); } - virtual bool Parse(std::vector<std::string> const& args); + bool Parse(std::vector<std::string> const& args) CM_OVERRIDE; enum { DoingType = DoingLast1, DoingRename, DoingLast2 }; - virtual bool CheckKeyword(std::string const& arg); - virtual bool CheckValue(std::string const& arg); - virtual void DefaultFilePermissions() + bool CheckKeyword(std::string const& arg) CM_OVERRIDE; + bool CheckValue(std::string const& arg) CM_OVERRIDE; + void DefaultFilePermissions() CM_OVERRIDE { this->cmFileCopier::DefaultFilePermissions(); // Add execute permissions based on the target type. @@ -1942,9 +1942,9 @@ bool cmFileCommand::HandleRPathChangeCommand( std::vector<std::string> const& args) { // Evaluate arguments. - const char* file = 0; - const char* oldRPath = 0; - const char* newRPath = 0; + const char* file = CM_NULLPTR; + const char* oldRPath = CM_NULLPTR; + const char* newRPath = CM_NULLPTR; enum Doing { DoingNone, @@ -2032,7 +2032,7 @@ bool cmFileCommand::HandleRPathRemoveCommand( std::vector<std::string> const& args) { // Evaluate arguments. - const char* file = 0; + const char* file = CM_NULLPTR; enum Doing { DoingNone, @@ -2096,8 +2096,8 @@ bool cmFileCommand::HandleRPathCheckCommand( std::vector<std::string> const& args) { // Evaluate arguments. - const char* file = 0; - const char* rpath = 0; + const char* file = CM_NULLPTR; + const char* rpath = CM_NULLPTR; enum Doing { DoingNone, @@ -2438,7 +2438,7 @@ public: inline void release(void) { - this->Easy = 0; + this->Easy = CM_NULLPTR; return; } @@ -2478,7 +2478,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) const char* cainfo = this->Makefile->GetDefinition("CMAKE_TLS_CAINFO"); std::string expectedHash; std::string hashMatchMSG; - cmsys::auto_ptr<cmCryptoHash> hash; + CM_AUTO_PTR<cmCryptoHash> hash; bool showProgress = false; while (i != args.end()) { @@ -2534,7 +2534,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) this->SetError("DOWNLOAD missing sum value for EXPECTED_MD5."); return false; } - hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New("MD5")); + hash = CM_AUTO_PTR<cmCryptoHash>(cmCryptoHash::New("MD5")); hashMatchMSG = "MD5 sum"; expectedHash = cmSystemTools::LowerCase(*i); } else if (*i == "SHOW_PROGRESS") { @@ -2555,7 +2555,7 @@ bool cmFileCommand::HandleDownloadCommand(std::vector<std::string> const& args) } std::string algo = i->substr(0, pos); expectedHash = cmSystemTools::LowerCase(i->substr(pos + 1)); - hash = cmsys::auto_ptr<cmCryptoHash>(cmCryptoHash::New(algo.c_str())); + hash = CM_AUTO_PTR<cmCryptoHash>(cmCryptoHash::New(algo.c_str())); if (!hash.get()) { std::string err = "DOWNLOAD EXPECTED_HASH given unknown ALGO: "; err += algo; @@ -2934,7 +2934,7 @@ bool cmFileCommand::HandleUploadCommand(std::vector<std::string> const& args) ::curl_global_cleanup(); fclose(fin); - fin = NULL; + fin = CM_NULLPTR; if (!logVar.empty()) { std::string log; @@ -2971,11 +2971,11 @@ void cmFileCommand::AddEvaluationFile(const std::string& inputName, cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); cmGeneratorExpression outputGe(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputCge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> outputCge = outputGe.Parse(outputExpr); cmGeneratorExpression conditionGe(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> conditionCge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> conditionCge = conditionGe.Parse(condition); this->Makefile->AddEvaluationFile(inputName, outputCge, conditionCge, diff --git a/Source/cmFileCommand.h b/Source/cmFileCommand.h index 84bb456..9121d3c 100644 --- a/Source/cmFileCommand.h +++ b/Source/cmFileCommand.h @@ -26,24 +26,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFileCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "file"; } + std::string GetName() const CM_OVERRIDE { return "file"; } cmTypeMacro(cmFileCommand, cmCommand); diff --git a/Source/cmFileTimeComparison.cxx b/Source/cmFileTimeComparison.cxx index 7efe194..9d63505 100644 --- a/Source/cmFileTimeComparison.cxx +++ b/Source/cmFileTimeComparison.cxx @@ -13,7 +13,7 @@ // Use a hash table to avoid duplicate file time checks from disk. #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP #include <unordered_map> #else #include <cmsys/hash_map.hxx> @@ -47,13 +47,13 @@ private: { public: size_t operator()(const std::string& s) const { return h(s.c_str()); } -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP std::hash<const char*> h; #else cmsys::hash<const char*> h; #endif }; -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, #else typedef cmsys::hash_map<std::string, diff --git a/Source/cmFindCommon.cxx b/Source/cmFindCommon.cxx index 638c1d1..d255ceb 100644 --- a/Source/cmFindCommon.cxx +++ b/Source/cmFindCommon.cxx @@ -234,13 +234,13 @@ void cmFindCommon::GetIgnoredPaths(std::vector<std::string>& ignore) { // null-terminated list of paths. static const char* paths[] = { "CMAKE_SYSTEM_IGNORE_PATH", - "CMAKE_IGNORE_PATH", 0 }; + "CMAKE_IGNORE_PATH", CM_NULLPTR }; // Construct the list of path roots with no trailing slashes. for (const char** pathName = paths; *pathName; ++pathName) { // Get the list of paths to ignore from the variable. const char* ignorePath = this->Makefile->GetDefinition(*pathName); - if ((ignorePath == 0) || (strlen(ignorePath) == 0)) { + if ((ignorePath == CM_NULLPTR) || (strlen(ignorePath) == 0)) { continue; } diff --git a/Source/cmFindCommon.h b/Source/cmFindCommon.h index ebec884..0f8d826 100644 --- a/Source/cmFindCommon.h +++ b/Source/cmFindCommon.h @@ -27,7 +27,7 @@ class cmFindCommon : public cmCommand { public: cmFindCommon(); - ~cmFindCommon(); + ~cmFindCommon() CM_OVERRIDE; cmTypeMacro(cmFindCommon, cmCommand); protected: diff --git a/Source/cmFindFileCommand.h b/Source/cmFindFileCommand.h index 74b01f1..68bd5b9 100644 --- a/Source/cmFindFileCommand.h +++ b/Source/cmFindFileCommand.h @@ -29,8 +29,8 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFindFileCommand; } - virtual std::string GetName() const { return "find_file"; } + cmCommand* Clone() CM_OVERRIDE { return new cmFindFileCommand; } + std::string GetName() const CM_OVERRIDE { return "find_file"; } cmTypeMacro(cmFindFileCommand, cmFindPathCommand); }; diff --git a/Source/cmFindLibraryCommand.h b/Source/cmFindLibraryCommand.h index a08e151..813decd 100644 --- a/Source/cmFindLibraryCommand.h +++ b/Source/cmFindLibraryCommand.h @@ -28,24 +28,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFindLibraryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFindLibraryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "find_library"; } + std::string GetName() const CM_OVERRIDE { return "find_library"; } cmTypeMacro(cmFindLibraryCommand, cmFindBase); diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx index d074b05..d5fd75d 100644 --- a/Source/cmFindPackageCommand.cxx +++ b/Source/cmFindPackageCommand.cxx @@ -1199,7 +1199,7 @@ public: cmSystemTools::RemoveFile(this->File); } } - void Release() { this->File = 0; } + void Release() { this->File = CM_NULLPTR; } }; void cmFindPackageCommand::LoadPackageRegistryDir(std::string const& dir, @@ -1500,9 +1500,9 @@ void cmFindPackageCommand::StoreVersionFound() this->Makefile->AddDefinition(ver + "_COUNT", buf); } +#include <cm_auto_ptr.hxx> #include <cmsys/Glob.hxx> #include <cmsys/String.h> -#include <cmsys/auto_ptr.hxx> class cmFileList; class cmFileListGeneratorBase @@ -1515,10 +1515,10 @@ protected: private: bool Search(cmFileList&); virtual bool Search(std::string const& parent, cmFileList&) = 0; - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const = 0; + virtual CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const = 0; friend class cmFileList; cmFileListGeneratorBase* SetNext(cmFileListGeneratorBase const& next); - cmsys::auto_ptr<cmFileListGeneratorBase> Next; + CM_AUTO_PTR<cmFileListGeneratorBase> Next; }; class cmFileList @@ -1526,7 +1526,7 @@ class cmFileList public: cmFileList() : First() - , Last(0) + , Last(CM_NULLPTR) { } virtual ~cmFileList() {} @@ -1551,7 +1551,7 @@ public: private: virtual bool Visit(std::string const& fullPath) = 0; friend class cmFileListGeneratorBase; - cmsys::auto_ptr<cmFileListGeneratorBase> First; + CM_AUTO_PTR<cmFileListGeneratorBase> First; cmFileListGeneratorBase* Last; }; @@ -1566,7 +1566,7 @@ public: } private: - bool Visit(std::string const& fullPath) + bool Visit(std::string const& fullPath) CM_OVERRIDE { if (this->UseSuffixes) { return this->FPC->SearchDirectory(fullPath); @@ -1616,14 +1616,14 @@ public: private: std::string String; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { std::string fullPath = parent + this->String; return this->Consider(fullPath, lister); } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( + CM_AUTO_PTR<cmFileListGeneratorBase> g( new cmFileListGeneratorFixed(*this)); return g; } @@ -1645,7 +1645,7 @@ public: private: std::vector<std::string> const& Vector; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { for (std::vector<std::string>::const_iterator i = this->Vector.begin(); i != this->Vector.end(); ++i) { @@ -1655,9 +1655,9 @@ private: } return false; } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( + CM_AUTO_PTR<cmFileListGeneratorBase> g( new cmFileListGeneratorEnumerate(*this)); return g; } @@ -1679,7 +1679,7 @@ public: private: std::vector<std::string> const& Names; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { // Construct a list of matches. std::vector<std::string> matches; @@ -1706,9 +1706,9 @@ private: } return false; } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( + CM_AUTO_PTR<cmFileListGeneratorBase> g( new cmFileListGeneratorProject(*this)); return g; } @@ -1734,7 +1734,7 @@ public: private: std::vector<std::string> const& Names; std::string Extension; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { // Construct a list of matches. std::vector<std::string> matches; @@ -1763,9 +1763,9 @@ private: } return false; } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( + CM_AUTO_PTR<cmFileListGeneratorBase> g( new cmFileListGeneratorMacProject(*this)); return g; } @@ -1788,7 +1788,7 @@ public: private: std::string String; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { // Look for matching files. std::vector<std::string> matches; @@ -1807,9 +1807,9 @@ private: } return false; } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( + CM_AUTO_PTR<cmFileListGeneratorBase> g( new cmFileListGeneratorCaseInsensitive(*this)); return g; } @@ -1831,7 +1831,7 @@ public: private: std::string Pattern; - virtual bool Search(std::string const& parent, cmFileList& lister) + bool Search(std::string const& parent, cmFileList& lister) CM_OVERRIDE { // Glob the set of matching files. std::string expr = parent; @@ -1853,10 +1853,9 @@ private: } return false; } - virtual cmsys::auto_ptr<cmFileListGeneratorBase> Clone() const + CM_AUTO_PTR<cmFileListGeneratorBase> Clone() const CM_OVERRIDE { - cmsys::auto_ptr<cmFileListGeneratorBase> g( - new cmFileListGeneratorGlob(*this)); + CM_AUTO_PTR<cmFileListGeneratorBase> g(new cmFileListGeneratorGlob(*this)); return g; } }; diff --git a/Source/cmFindPackageCommand.h b/Source/cmFindPackageCommand.h index 2d14be2..087107e 100644 --- a/Source/cmFindPackageCommand.h +++ b/Source/cmFindPackageCommand.h @@ -29,24 +29,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFindPackageCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFindPackageCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "find_package"; } + std::string GetName() const CM_OVERRIDE { return "find_package"; } cmTypeMacro(cmFindPackageCommand, cmFindCommon); diff --git a/Source/cmFindPathCommand.h b/Source/cmFindPathCommand.h index e14626a..52ce3b0 100644 --- a/Source/cmFindPathCommand.h +++ b/Source/cmFindPathCommand.h @@ -28,24 +28,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFindPathCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFindPathCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "find_path"; } + std::string GetName() const CM_OVERRIDE { return "find_path"; } cmTypeMacro(cmFindPathCommand, cmFindBase); bool IncludeFileInPath; diff --git a/Source/cmFindProgramCommand.h b/Source/cmFindProgramCommand.h index 3f2ac0e..1953f59 100644 --- a/Source/cmFindProgramCommand.h +++ b/Source/cmFindProgramCommand.h @@ -29,24 +29,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFindProgramCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFindProgramCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "find_program"; } + std::string GetName() const CM_OVERRIDE { return "find_program"; } cmTypeMacro(cmFindProgramCommand, cmFindBase); diff --git a/Source/cmForEachCommand.cxx b/Source/cmForEachCommand.cxx index daf43e6..c6e5f06 100644 --- a/Source/cmForEachCommand.cxx +++ b/Source/cmForEachCommand.cxx @@ -11,7 +11,7 @@ ============================================================================*/ #include "cmForEachCommand.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> cmForEachFunctionBlocker::cmForEachFunctionBlocker(cmMakefile* mf) : Makefile(mf) @@ -36,8 +36,7 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, // if this is the endofreach for this statement if (!this->Depth) { // Remove the function blocker for this scope or bail. - cmsys::auto_ptr<cmFunctionBlocker> fb( - mf.RemoveFunctionBlocker(this, lff)); + CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff)); if (!fb.get()) { return false; } @@ -184,7 +183,7 @@ bool cmForEachCommand::InitialPass(std::vector<std::string> const& args, bool cmForEachCommand::HandleInMode(std::vector<std::string> const& args) { - cmsys::auto_ptr<cmForEachFunctionBlocker> f( + CM_AUTO_PTR<cmForEachFunctionBlocker> f( new cmForEachFunctionBlocker(this->Makefile)); f->Args.push_back(args[0]); diff --git a/Source/cmForEachCommand.h b/Source/cmForEachCommand.h index 60956aa..887e6e9 100644 --- a/Source/cmForEachCommand.h +++ b/Source/cmForEachCommand.h @@ -21,10 +21,10 @@ class cmForEachFunctionBlocker : public cmFunctionBlocker { public: cmForEachFunctionBlocker(cmMakefile* mf); - ~cmForEachFunctionBlocker(); - virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, - cmExecutionStatus&); - virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf); + ~cmForEachFunctionBlocker() CM_OVERRIDE; + bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; + bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE; std::vector<std::string> Args; std::vector<cmListFileFunction> Functions; @@ -41,24 +41,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmForEachCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmForEachCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "foreach"; } + std::string GetName() const CM_OVERRIDE { return "foreach"; } cmTypeMacro(cmForEachCommand, cmCommand); diff --git a/Source/cmFortranParserImpl.cxx b/Source/cmFortranParserImpl.cxx index 934e928..a72204a 100644 --- a/Source/cmFortranParserImpl.cxx +++ b/Source/cmFortranParserImpl.cxx @@ -65,7 +65,8 @@ cmFortranParser_s::cmFortranParser_s(std::vector<std::string> const& includes, // Create a dummy buffer that is never read but is the fallback // buffer when the last file is popped off the stack. - YY_BUFFER_STATE buffer = cmFortran_yy_create_buffer(0, 4, this->Scanner); + YY_BUFFER_STATE buffer = + cmFortran_yy_create_buffer(CM_NULLPTR, 4, this->Scanner); cmFortran_yy_switch_to_buffer(buffer, this->Scanner); } @@ -83,7 +84,7 @@ bool cmFortranParser_FilePush(cmFortranParser* parser, const char* fname) std::string dir = cmSystemTools::GetParentDirectory(fname); cmFortranFile f(file, current, dir); YY_BUFFER_STATE buffer = - cmFortran_yy_create_buffer(0, 16384, parser->Scanner); + cmFortran_yy_create_buffer(CM_NULLPTR, 16384, parser->Scanner); cmFortran_yy_switch_to_buffer(buffer, parser->Scanner); parser->FileStack.push(f); return 1; diff --git a/Source/cmFunctionCommand.cxx b/Source/cmFunctionCommand.cxx index de9887e..40c54db 100644 --- a/Source/cmFunctionCommand.cxx +++ b/Source/cmFunctionCommand.cxx @@ -20,7 +20,7 @@ public: cmFunctionHelperCommand() {} ///! clean up any memory allocated by the function - ~cmFunctionHelperCommand() {} + ~cmFunctionHelperCommand() CM_OVERRIDE {} /** * This is used to avoid including this command @@ -28,12 +28,12 @@ public: * cmMacroHelperCommand and cmFunctionHelperCommand * which cannot provide appropriate documentation. */ - virtual bool ShouldAppearInDocumentation() const { return false; } + bool ShouldAppearInDocumentation() const CM_OVERRIDE { return false; } /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmFunctionHelperCommand* newC = new cmFunctionHelperCommand; // we must copy when we clone @@ -47,16 +47,17 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&); + bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, + cmExecutionStatus&) CM_OVERRIDE; - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -64,7 +65,7 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return this->Args[0]; } + std::string GetName() const CM_OVERRIDE { return this->Args[0]; } cmTypeMacro(cmFunctionHelperCommand, cmCommand); diff --git a/Source/cmFunctionCommand.h b/Source/cmFunctionCommand.h index 08f7f0f..2c7a884 100644 --- a/Source/cmFunctionCommand.h +++ b/Source/cmFunctionCommand.h @@ -20,10 +20,10 @@ class cmFunctionFunctionBlocker : public cmFunctionBlocker { public: cmFunctionFunctionBlocker() { this->Depth = 0; } - virtual ~cmFunctionFunctionBlocker() {} - virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf, - cmExecutionStatus&); - virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf); + ~cmFunctionFunctionBlocker() CM_OVERRIDE {} + bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; + bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf) CM_OVERRIDE; std::vector<std::string> Args; std::vector<cmListFileFunction> Functions; @@ -37,24 +37,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmFunctionCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmFunctionCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "function"; } + std::string GetName() const CM_OVERRIDE { return "function"; } cmTypeMacro(cmFunctionCommand, cmCommand); }; diff --git a/Source/cmGeneratedFileStream.h b/Source/cmGeneratedFileStream.h index a2de5bc..3480c5b 100644 --- a/Source/cmGeneratedFileStream.h +++ b/Source/cmGeneratedFileStream.h @@ -99,7 +99,7 @@ public: * file was successfully written before allowing the original to be * replaced. */ - ~cmGeneratedFileStream(); + ~cmGeneratedFileStream() CM_OVERRIDE; /** * Open an output file by name. This should be used only with a diff --git a/Source/cmGeneratorExpression.cxx b/Source/cmGeneratorExpression.cxx index 53243b8..983bfb4 100644 --- a/Source/cmGeneratorExpression.cxx +++ b/Source/cmGeneratorExpression.cxx @@ -26,14 +26,14 @@ cmGeneratorExpression::cmGeneratorExpression( { } -cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse( +CM_AUTO_PTR<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse( std::string const& input) { - return cmsys::auto_ptr<cmCompiledGeneratorExpression>( + return CM_AUTO_PTR<cmCompiledGeneratorExpression>( new cmCompiledGeneratorExpression(this->Backtrace, input)); } -cmsys::auto_ptr<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse( +CM_AUTO_PTR<cmCompiledGeneratorExpression> cmGeneratorExpression::Parse( const char* input) { return this->Parse(std::string(input ? input : "")); diff --git a/Source/cmGeneratorExpression.h b/Source/cmGeneratorExpression.h index 71fbba3..2f91608 100644 --- a/Source/cmGeneratorExpression.h +++ b/Source/cmGeneratorExpression.h @@ -17,8 +17,8 @@ #include "cmListFileCache.h" +#include <cm_auto_ptr.hxx> #include <cmsys/RegularExpression.hxx> -#include <cmsys/auto_ptr.hxx> class cmGeneratorTarget; class cmLocalGenerator; @@ -47,9 +47,8 @@ public: cmListFileBacktrace const& backtrace = cmListFileBacktrace()); ~cmGeneratorExpression(); - cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse( - std::string const& input); - cmsys::auto_ptr<cmCompiledGeneratorExpression> Parse(const char* input); + CM_AUTO_PTR<cmCompiledGeneratorExpression> Parse(std::string const& input); + CM_AUTO_PTR<cmCompiledGeneratorExpression> Parse(const char* input); enum PreprocessContext { @@ -81,12 +80,12 @@ private: class cmCompiledGeneratorExpression { public: - const char* Evaluate(cmLocalGenerator* lg, const std::string& config, - bool quiet = false, - cmGeneratorTarget const* headTarget = 0, - cmGeneratorTarget const* currentTarget = 0, - cmGeneratorExpressionDAGChecker* dagChecker = 0, - std::string const& language = std::string()) const; + const char* Evaluate( + cmLocalGenerator* lg, const std::string& config, bool quiet = false, + cmGeneratorTarget const* headTarget = CM_NULLPTR, + cmGeneratorTarget const* currentTarget = CM_NULLPTR, + cmGeneratorExpressionDAGChecker* dagChecker = CM_NULLPTR, + std::string const& language = std::string()) const; const char* Evaluate(cmLocalGenerator* lg, const std::string& config, bool quiet, cmGeneratorTarget const* headTarget, cmGeneratorExpressionDAGChecker* dagChecker, diff --git a/Source/cmGeneratorExpressionDAGChecker.h b/Source/cmGeneratorExpressionDAGChecker.h index 28ca824..6b7fe9a 100644 --- a/Source/cmGeneratorExpressionDAGChecker.h +++ b/Source/cmGeneratorExpressionDAGChecker.h @@ -63,7 +63,7 @@ struct cmGeneratorExpressionDAGChecker void ReportError(cmGeneratorExpressionContext* context, const std::string& expr); - bool EvaluatingLinkLibraries(const char* tgt = 0); + bool EvaluatingLinkLibraries(const char* tgt = CM_NULLPTR); #define DECLARE_TRANSITIVE_PROPERTY_METHOD(METHOD) bool METHOD() const; diff --git a/Source/cmGeneratorExpressionEvaluationFile.cxx b/Source/cmGeneratorExpressionEvaluationFile.cxx index 5b48eea..c01c4fc 100644 --- a/Source/cmGeneratorExpressionEvaluationFile.cxx +++ b/Source/cmGeneratorExpressionEvaluationFile.cxx @@ -23,9 +23,8 @@ cmGeneratorExpressionEvaluationFile::cmGeneratorExpressionEvaluationFile( const std::string& input, - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr, - cmsys::auto_ptr<cmCompiledGeneratorExpression> condition, - bool inputIsContent) + CM_AUTO_PTR<cmCompiledGeneratorExpression> outputFileExpr, + CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent) : Input(input) , OutputFileExpr(outputFileExpr) , Condition(condition) @@ -40,8 +39,8 @@ void cmGeneratorExpressionEvaluationFile::Generate( { std::string rawCondition = this->Condition->GetInput(); if (!rawCondition.empty()) { - std::string condResult = - this->Condition->Evaluate(lg, config, false, 0, 0, 0, lang); + std::string condResult = this->Condition->Evaluate( + lg, config, false, CM_NULLPTR, CM_NULLPTR, CM_NULLPTR, lang); if (condResult == "0") { return; } @@ -56,10 +55,10 @@ void cmGeneratorExpressionEvaluationFile::Generate( } } - const std::string outputFileName = - this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, lang); - const std::string outputContent = - inputExpression->Evaluate(lg, config, false, 0, 0, 0, lang); + const std::string outputFileName = this->OutputFileExpr->Evaluate( + lg, config, false, CM_NULLPTR, CM_NULLPTR, CM_NULLPTR, lang); + const std::string outputContent = inputExpression->Evaluate( + lg, config, false, CM_NULLPTR, CM_NULLPTR, CM_NULLPTR, lang); std::map<std::string, std::string>::iterator it = outputFiles.find(outputFileName); @@ -97,8 +96,8 @@ void cmGeneratorExpressionEvaluationFile::CreateOutputFile( for (std::vector<std::string>::const_iterator le = enabledLanguages.begin(); le != enabledLanguages.end(); ++le) { - std::string name = - this->OutputFileExpr->Evaluate(lg, config, false, 0, 0, 0, *le); + std::string name = this->OutputFileExpr->Evaluate( + lg, config, false, CM_NULLPTR, CM_NULLPTR, CM_NULLPTR, *le); cmSourceFile* sf = lg->GetMakefile()->GetOrCreateSource(name); sf->SetProperty("GENERATED", "1"); @@ -135,7 +134,7 @@ void cmGeneratorExpressionEvaluationFile::Generate(cmLocalGenerator* lg) cmListFileBacktrace lfbt = this->OutputFileExpr->GetBacktrace(); cmGeneratorExpression contentGE(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> inputExpression = + CM_AUTO_PTR<cmCompiledGeneratorExpression> inputExpression = contentGE.Parse(inputContent); std::map<std::string, std::string> outputFiles; diff --git a/Source/cmGeneratorExpressionEvaluationFile.h b/Source/cmGeneratorExpressionEvaluationFile.h index bfd6add..52ba2d8 100644 --- a/Source/cmGeneratorExpressionEvaluationFile.h +++ b/Source/cmGeneratorExpressionEvaluationFile.h @@ -14,7 +14,7 @@ #include "cmGeneratorExpression.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> #include <sys/types.h> class cmLocalGenerator; @@ -24,9 +24,8 @@ class cmGeneratorExpressionEvaluationFile public: cmGeneratorExpressionEvaluationFile( const std::string& input, - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputFileExpr, - cmsys::auto_ptr<cmCompiledGeneratorExpression> condition, - bool inputIsContent); + CM_AUTO_PTR<cmCompiledGeneratorExpression> outputFileExpr, + CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent); void Generate(cmLocalGenerator* lg); @@ -42,8 +41,8 @@ private: private: const std::string Input; - const cmsys::auto_ptr<cmCompiledGeneratorExpression> OutputFileExpr; - const cmsys::auto_ptr<cmCompiledGeneratorExpression> Condition; + const CM_AUTO_PTR<cmCompiledGeneratorExpression> OutputFileExpr; + const CM_AUTO_PTR<cmCompiledGeneratorExpression> Condition; std::vector<std::string> Files; const bool InputIsContent; }; diff --git a/Source/cmGeneratorExpressionEvaluator.h b/Source/cmGeneratorExpressionEvaluator.h index 7ca62c5..58e732b 100644 --- a/Source/cmGeneratorExpressionEvaluator.h +++ b/Source/cmGeneratorExpressionEvaluator.h @@ -52,12 +52,15 @@ struct TextContent : public cmGeneratorExpressionEvaluator } std::string Evaluate(cmGeneratorExpressionContext*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return std::string(this->Content, this->Length); } - Type GetType() const { return cmGeneratorExpressionEvaluator::Text; } + Type GetType() const CM_OVERRIDE + { + return cmGeneratorExpressionEvaluator::Text; + } void Extend(size_t length) { this->Length += length; } @@ -82,14 +85,17 @@ struct GeneratorExpressionContent : public cmGeneratorExpressionEvaluator this->ParamChildren = parameters; } - Type GetType() const { return cmGeneratorExpressionEvaluator::Generator; } + Type GetType() const CM_OVERRIDE + { + return cmGeneratorExpressionEvaluator::Generator; + } std::string Evaluate(cmGeneratorExpressionContext* context, - cmGeneratorExpressionDAGChecker*) const; + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE; std::string GetOriginalExpression() const; - ~GeneratorExpressionContent(); + ~GeneratorExpressionContent() CM_OVERRIDE; private: std::string EvaluateParameters(const cmGeneratorExpressionNode* node, diff --git a/Source/cmGeneratorExpressionNode.cxx b/Source/cmGeneratorExpressionNode.cxx index e750551..ca7250b 100644 --- a/Source/cmGeneratorExpressionNode.cxx +++ b/Source/cmGeneratorExpressionNode.cxx @@ -24,7 +24,7 @@ std::string cmGeneratorExpressionNode::EvaluateDependentExpression( cmGeneratorExpressionDAGChecker* dagChecker) { cmGeneratorExpression ge(context->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(prop); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(prop); cge->SetEvaluateForBuildsystem(context->EvaluateForBuildsystem); std::string result = cge->Evaluate(lg, context->Config, context->Quiet, headTarget, @@ -42,14 +42,14 @@ static const struct ZeroNode : public cmGeneratorExpressionNode { ZeroNode() {} - virtual bool GeneratesContent() const { return false; } + bool GeneratesContent() const CM_OVERRIDE { return false; } - virtual bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return std::string(); } @@ -59,12 +59,12 @@ static const struct OneNode : public cmGeneratorExpressionNode { OneNode() {} - virtual bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return parameters.front(); } @@ -113,7 +113,7 @@ static const struct NotNode : public cmGeneratorExpressionNode std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { if (*parameters.begin() != "0" && *parameters.begin() != "1") { reportError( @@ -129,12 +129,12 @@ static const struct BoolNode : public cmGeneratorExpressionNode { BoolNode() {} - virtual int NumExpectedParameters() const { return 1; } + int NumExpectedParameters() const CM_OVERRIDE { return 1; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return !cmSystemTools::IsOff(parameters.begin()->c_str()) ? "1" : "0"; } @@ -144,12 +144,12 @@ static const struct StrEqualNode : public cmGeneratorExpressionNode { StrEqualNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return *parameters.begin() == parameters[1] ? "1" : "0"; } @@ -159,12 +159,12 @@ static const struct EqualNode : public cmGeneratorExpressionNode { EqualNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { char* pEnd; @@ -236,12 +236,12 @@ static const struct LowerCaseNode : public cmGeneratorExpressionNode { LowerCaseNode() {} - bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::LowerCase(parameters.front()); } @@ -251,12 +251,12 @@ static const struct UpperCaseNode : public cmGeneratorExpressionNode { UpperCaseNode() {} - bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::UpperCase(parameters.front()); } @@ -266,12 +266,12 @@ static const struct MakeCIdentifierNode : public cmGeneratorExpressionNode { MakeCIdentifierNode() {} - bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::MakeCidentifier(parameters.front()); } @@ -281,12 +281,12 @@ static const struct Angle_RNode : public cmGeneratorExpressionNode { Angle_RNode() {} - virtual int NumExpectedParameters() const { return 0; } + int NumExpectedParameters() const CM_OVERRIDE { return 0; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return ">"; } @@ -296,12 +296,12 @@ static const struct CommaNode : public cmGeneratorExpressionNode { CommaNode() {} - virtual int NumExpectedParameters() const { return 0; } + int NumExpectedParameters() const CM_OVERRIDE { return 0; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return ","; } @@ -311,12 +311,12 @@ static const struct SemicolonNode : public cmGeneratorExpressionNode { SemicolonNode() {} - virtual int NumExpectedParameters() const { return 0; } + int NumExpectedParameters() const CM_OVERRIDE { return 0; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return ";"; } @@ -326,7 +326,7 @@ struct CompilerIdNode : public cmGeneratorExpressionNode { CompilerIdNode() {} - virtual int NumExpectedParameters() const { return OneOrZeroParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrZeroParameters; } std::string EvaluateWithLanguage(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, @@ -381,6 +381,7 @@ static const struct CCompilerIdNode : public CompilerIdNode cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { if (!context->HeadTarget) { reportError( @@ -402,6 +403,7 @@ static const struct CXXCompilerIdNode : public CompilerIdNode cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { if (!context->HeadTarget) { reportError( @@ -419,7 +421,7 @@ struct CompilerVersionNode : public cmGeneratorExpressionNode { CompilerVersionNode() {} - virtual int NumExpectedParameters() const { return OneOrZeroParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrZeroParameters; } std::string EvaluateWithLanguage(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, @@ -460,6 +462,7 @@ static const struct CCompilerVersionNode : public CompilerVersionNode cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { if (!context->HeadTarget) { reportError( @@ -481,6 +484,7 @@ static const struct CxxCompilerVersionNode : public CompilerVersionNode cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { if (!context->HeadTarget) { reportError( @@ -498,12 +502,12 @@ struct PlatformIdNode : public cmGeneratorExpressionNode { PlatformIdNode() {} - virtual int NumExpectedParameters() const { return OneOrZeroParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrZeroParameters; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { const char* platformId = context->LG->GetMakefile()->GetSafeDefinition("CMAKE_SYSTEM_NAME"); @@ -526,12 +530,12 @@ static const struct VersionGreaterNode : public cmGeneratorExpressionNode { VersionGreaterNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::VersionCompare(cmSystemTools::OP_GREATER, parameters.front().c_str(), @@ -545,12 +549,12 @@ static const struct VersionLessNode : public cmGeneratorExpressionNode { VersionLessNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::VersionCompare(cmSystemTools::OP_LESS, parameters.front().c_str(), @@ -564,12 +568,12 @@ static const struct VersionEqualNode : public cmGeneratorExpressionNode { VersionEqualNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return cmSystemTools::VersionCompare(cmSystemTools::OP_EQUAL, parameters.front().c_str(), @@ -583,10 +587,10 @@ static const struct LinkOnlyNode : public cmGeneratorExpressionNode { LinkOnlyNode() {} - std::string Evaluate(const std::vector<std::string>& parameters, - cmGeneratorExpressionContext*, - const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker* dagChecker) const + std::string Evaluate( + const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, + const GeneratorExpressionContent*, + cmGeneratorExpressionDAGChecker* dagChecker) const CM_OVERRIDE { if (!dagChecker->GetTransitivePropertiesOnly()) { return parameters.front(); @@ -599,12 +603,12 @@ static const struct ConfigurationNode : public cmGeneratorExpressionNode { ConfigurationNode() {} - virtual int NumExpectedParameters() const { return 0; } + int NumExpectedParameters() const CM_OVERRIDE { return 0; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext* context, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { context->HadContextSensitiveCondition = true; return context->Config; @@ -615,15 +619,16 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode { ConfigurationTestNode() {} - virtual int NumExpectedParameters() const { return OneOrZeroParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrZeroParameters; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { if (parameters.empty()) { - return configurationNode.Evaluate(parameters, context, content, 0); + return configurationNode.Evaluate(parameters, context, content, + CM_NULLPTR); } static cmsys::RegularExpression configValidator("^[A-Za-z0-9_]*$"); if (!configValidator.find(*parameters.begin())) { @@ -642,8 +647,8 @@ static const struct ConfigurationTestNode : public cmGeneratorExpressionNode } if (context->CurrentTarget && context->CurrentTarget->IsImported()) { - const char* loc = 0; - const char* imp = 0; + const char* loc = CM_NULLPTR; + const char* imp = CM_NULLPTR; std::string suffix; if (context->CurrentTarget->Target->GetMappedConfig( context->Config, &loc, &imp, suffix)) { @@ -673,14 +678,14 @@ static const struct JoinNode : public cmGeneratorExpressionNode { JoinNode() {} - virtual int NumExpectedParameters() const { return 2; } + int NumExpectedParameters() const CM_OVERRIDE { return 2; } - virtual bool AcceptsArbitraryContentParameter() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { std::vector<std::string> list; cmSystemTools::ExpandListArgument(parameters.front(), list); @@ -692,12 +697,13 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode { CompileLanguageNode() {} - virtual int NumExpectedParameters() const { return OneOrZeroParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrZeroParameters; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { if (context->Language.empty()) { reportError( @@ -753,7 +759,7 @@ static const struct CompileLanguageNode : public cmGeneratorExpressionNode #define TRANSITIVE_PROPERTY_NAME(PROPERTY) , "INTERFACE_" #PROPERTY static const char* targetPropertyTransitiveWhitelist[] = { - 0 CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME) + CM_NULLPTR CM_FOR_EACH_TRANSITIVE_PROPERTY_NAME(TRANSITIVE_PROPERTY_NAME) }; #undef TRANSITIVE_PROPERTY_NAME @@ -795,12 +801,13 @@ static const struct TargetPropertyNode : public cmGeneratorExpressionNode TargetPropertyNode() {} // This node handles errors on parameter count itself. - virtual int NumExpectedParameters() const { return OneOrMoreParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrMoreParameters; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagCheckerParent) const + CM_OVERRIDE { if (parameters.size() != 1 && parameters.size() != 2) { reportError( @@ -1087,20 +1094,20 @@ static const struct TargetNameNode : public cmGeneratorExpressionNode { TargetNameNode() {} - virtual bool GeneratesContent() const { return true; } + bool GeneratesContent() const CM_OVERRIDE { return true; } - virtual bool AcceptsArbitraryContentParameter() const { return true; } - virtual bool RequiresLiteralInput() const { return true; } + bool AcceptsArbitraryContentParameter() const CM_OVERRIDE { return true; } + bool RequiresLiteralInput() const CM_OVERRIDE { return true; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext*, const GeneratorExpressionContent*, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { return parameters.front(); } - virtual int NumExpectedParameters() const { return 1; } + int NumExpectedParameters() const CM_OVERRIDE { return 1; } } targetNameNode; @@ -1111,7 +1118,7 @@ static const struct TargetObjectsNode : public cmGeneratorExpressionNode std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { if (!context->EvaluateForBuildsystem) { std::ostringstream e; @@ -1179,12 +1186,13 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode { CompileFeaturesNode() {} - virtual int NumExpectedParameters() const { return OneOrMoreParameters; } + int NumExpectedParameters() const CM_OVERRIDE { return OneOrMoreParameters; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { cmGeneratorTarget const* target = context->HeadTarget; if (!target) { @@ -1263,10 +1271,10 @@ static const struct CompileFeaturesNode : public cmGeneratorExpressionNode } compileFeaturesNode; static const char* targetPolicyWhitelist[] = { - 0 + CM_NULLPTR #define TARGET_POLICY_STRING(POLICY) , #POLICY - CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING) + CM_FOR_EACH_TARGET_POLICY(TARGET_POLICY_STRING) #undef TARGET_POLICY_STRING }; @@ -1306,12 +1314,12 @@ static const struct TargetPolicyNode : public cmGeneratorExpressionNode { TargetPolicyNode() {} - virtual int NumExpectedParameters() const { return 1; } + int NumExpectedParameters() const CM_OVERRIDE { return 1; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { if (!context->HeadTarget) { reportError( @@ -1365,13 +1373,13 @@ static const struct InstallPrefixNode : public cmGeneratorExpressionNode { InstallPrefixNode() {} - virtual bool GeneratesContent() const { return true; } - virtual int NumExpectedParameters() const { return 0; } + bool GeneratesContent() const CM_OVERRIDE { return true; } + int NumExpectedParameters() const CM_OVERRIDE { return 0; } std::string Evaluate(const std::vector<std::string>&, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { reportError(context, content->GetOriginalExpression(), "INSTALL_PREFIX is a marker for install(EXPORT) only. It " @@ -1529,12 +1537,13 @@ struct TargetFilesystemArtifact : public cmGeneratorExpressionNode { TargetFilesystemArtifact() {} - virtual int NumExpectedParameters() const { return 1; } + int NumExpectedParameters() const CM_OVERRIDE { return 1; } std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, cmGeneratorExpressionDAGChecker* dagChecker) const + CM_OVERRIDE { // Lookup the referenced target. std::string name = *parameters.begin(); @@ -1606,7 +1615,7 @@ static const struct ShellPathNode : public cmGeneratorExpressionNode std::string Evaluate(const std::vector<std::string>& parameters, cmGeneratorExpressionContext* context, const GeneratorExpressionContent* content, - cmGeneratorExpressionDAGChecker*) const + cmGeneratorExpressionDAGChecker*) const CM_OVERRIDE { if (!cmSystemTools::FileIsFullPath(parameters.front())) { reportError(context, content->GetOriginalExpression(), @@ -1675,7 +1684,7 @@ const cmGeneratorExpressionNode* cmGeneratorExpressionNode::GetNode( } NodeMap::const_iterator i = nodeMap.find(identifier); if (i == nodeMap.end()) { - return 0; + return CM_NULLPTR; } return i->second; } diff --git a/Source/cmGeneratorTarget.cxx b/Source/cmGeneratorTarget.cxx index 9a025d9..c9cbd00 100644 --- a/Source/cmGeneratorTarget.cxx +++ b/Source/cmGeneratorTarget.cxx @@ -27,7 +27,10 @@ #include "assert.h" #include <errno.h> -#if defined(CMAKE_BUILD_WITH_CMAKE) +#if defined(CMake_HAVE_CXX_UNORDERED_SET) +#include <unordered_set> +#define UNORDERED_SET std::unordered_set +#elif defined(CMAKE_BUILD_WITH_CMAKE) #include <cmsys/hash_set.hxx> #define UNORDERED_SET cmsys::hash_set #else @@ -39,13 +42,13 @@ class cmGeneratorTarget::TargetPropertyEntry static cmLinkImplItem NoLinkImplItem; public: - TargetPropertyEntry(cmsys::auto_ptr<cmCompiledGeneratorExpression> cge, + TargetPropertyEntry(CM_AUTO_PTR<cmCompiledGeneratorExpression> cge, cmLinkImplItem const& item = NoLinkImplItem) : ge(cge) , LinkImplItem(item) { } - const cmsys::auto_ptr<cmCompiledGeneratorExpression> ge; + const CM_AUTO_PTR<cmCompiledGeneratorExpression> ge; cmLinkImplItem const& LinkImplItem; }; cmLinkImplItem cmGeneratorTarget::TargetPropertyEntry::NoLinkImplItem; @@ -250,7 +253,7 @@ void CreatePropertyGeneratorExpressions( for (std::vector<std::string>::const_iterator it = entries.begin(); it != entries.end(); ++it, ++btIt) { cmGeneratorExpression ge(*btIt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*it); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*it); cge->SetEvaluateForBuildsystem(evaluateForBuildsystem); items.push_back(new cmGeneratorTarget::TargetPropertyEntry(cge)); } @@ -440,7 +443,7 @@ std::string cmGeneratorTarget::GetOutputName(const std::string& config, // Now evaluate genex and update the previously-prepared map entry. cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outName); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(outName); i->second = cge->Evaluate(this->LocalGenerator, config); } else if (i->second.empty()) { // An empty map entry indicates we have been called recursively @@ -458,7 +461,7 @@ void cmGeneratorTarget::AddSource(const std::string& src) this->Target->AddSource(src); cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(src); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(src); cge->SetEvaluateForBuildsystem(true); this->SourceEntries.push_back(new TargetPropertyEntry(cge)); this->SourceFilesMap.clear(); @@ -474,7 +477,7 @@ void cmGeneratorTarget::AddTracedSources(std::vector<std::string> const& srcs) this->LinkImplementationLanguageIsContextDependent = true; cmListFileBacktrace lfbt = this->Makefile->GetBacktrace(); cmGeneratorExpression ge(lfbt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(srcFiles); cge->SetEvaluateForBuildsystem(true); this->SourceEntries.push_back( new cmGeneratorTarget::TargetPropertyEntry(cge)); @@ -488,7 +491,7 @@ std::vector<cmSourceFile*> const* cmGeneratorTarget::GetSourceDepends( if (i != this->SourceDepends.end()) { return &i->second.Depends; } - return 0; + return CM_NULLPTR; } static void handleSystemIncludesDep( @@ -799,7 +802,7 @@ bool cmGeneratorTarget::IsSystemIncludeDirectory( if (iter == this->SystemIncludesCache.end()) { cmGeneratorExpressionDAGChecker dagChecker( - this->GetName(), "SYSTEM_INCLUDE_DIRECTORIES", 0, 0); + this->GetName(), "SYSTEM_INCLUDE_DIRECTORIES", CM_NULLPTR, CM_NULLPTR); bool excludeImported = this->GetPropertyAsBool("NO_SYSTEM_FROM_IMPORTED"); @@ -859,7 +862,7 @@ static void AddInterfaceEntries( if (it->Target) { std::string genex = "$<TARGET_PROPERTY:" + *it + "," + prop + ">"; cmGeneratorExpression ge(it->Backtrace); - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(genex); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(genex); cge->SetEvaluateForBuildsystem(true); entries.push_back( new cmGeneratorTarget::TargetPropertyEntry(cge, *it)); @@ -995,7 +998,8 @@ void cmGeneratorTarget::GetSourceFiles(std::vector<std::string>& files, this->DebugSourcesDone = true; } - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), "SOURCES", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), "SOURCES", + CM_NULLPTR, CM_NULLPTR); UNORDERED_SET<std::string> uniqueSrcs; bool contextDependentDirectSources = @@ -1503,7 +1507,7 @@ const char* cmGeneratorTarget::GetExportMacro() const } return this->ExportMacro.c_str(); } else { - return 0; + return CM_NULLPTR; } } @@ -1747,7 +1751,7 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( { // There is no compile information for imported targets. if (this->IsImported()) { - return 0; + return CM_NULLPTR; } if (this->GetType() > cmState::OBJECT_LIBRARY) { @@ -1756,7 +1760,7 @@ cmGeneratorTarget::CompileInfo const* cmGeneratorTarget::GetCompileInfo( msg += " which has type "; msg += cmState::GetTargetTypeName(this->GetType()); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); - return 0; + return CM_NULLPTR; } // Lookup/compute/cache the compile information for this configuration. @@ -1785,7 +1789,7 @@ cmSourceFile const* cmGeneratorTarget::GetModuleDefinitionFile( return data.front(); } - return 0; + return CM_NULLPTR; } bool cmGeneratorTarget::IsDLLPlatform() const @@ -1838,8 +1842,8 @@ void cmGeneratorTarget::GetAutoUicOptions(std::vector<std::string>& result, } cmGeneratorExpression ge; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "AUTOUIC_OPTIONS", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "AUTOUIC_OPTIONS", CM_NULLPTR, CM_NULLPTR); cmSystemTools::ExpandListArgument( ge.Parse(prop)->Evaluate(this->LocalGenerator, config, false, this, &dagChecker), @@ -1924,7 +1928,7 @@ cmTargetTraceDependencies::cmTargetTraceDependencies(cmGeneratorTarget* target) this->Makefile = target->Target->GetMakefile(); this->LocalGenerator = target->GetLocalGenerator(); this->GlobalGenerator = this->LocalGenerator->GetGlobalGenerator(); - this->CurrentEntry = 0; + this->CurrentEntry = CM_NULLPTR; // Queue all the source files already specified for the target. if (target->GetType() != cmState::INTERFACE_LIBRARY) { @@ -1999,7 +2003,7 @@ void cmTargetTraceDependencies::Trace() this->CheckCustomCommand(*cc); } } - this->CurrentEntry = 0; + this->CurrentEntry = CM_NULLPTR; this->GeneratorTarget->AddTracedSources(this->NewSources); } @@ -2115,8 +2119,7 @@ void cmTargetTraceDependencies::CheckCustomCommand(cmCustomCommand const& cc) // Check for target references in generator expressions. for (cmCustomCommandLine::const_iterator cli = cit->begin(); cli != cit->end(); ++cli) { - const cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(*cli); + const CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*cli); cge->Evaluate(this->GeneratorTarget->GetLocalGenerator(), "", true); std::set<cmGeneratorTarget*> geTargets = cge->GetTargets(); targets.insert(geTargets.begin(), geTargets.end()); @@ -2199,7 +2202,7 @@ std::string cmGeneratorTarget::GetCompilePDBDirectory( void cmGeneratorTarget::GetAppleArchs(const std::string& config, std::vector<std::string>& archVec) const { - const char* archs = 0; + const char* archs = CM_NULLPTR; if (!config.empty()) { std::string defVarName = "OSX_ARCHITECTURES_"; defVarName += cmSystemTools::UpperCase(config); @@ -2357,8 +2360,8 @@ std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories( std::vector<std::string> includes; UNORDERED_SET<std::string> uniqueIncludes; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "INCLUDE_DIRECTORIES", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "INCLUDE_DIRECTORIES", CM_NULLPTR, CM_NULLPTR); std::vector<std::string> debugProperties; const char* debugProp = @@ -2401,7 +2404,7 @@ std::vector<std::string> cmGeneratorTarget::GetIncludeDirectories( libDir = frameworkCheck.match(1); cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(libDir.c_str()); linkInterfaceIncludeDirectoriesEntries.push_back( new cmGeneratorTarget::TargetPropertyEntry(cge)); @@ -2484,8 +2487,8 @@ void cmGeneratorTarget::GetCompileOptions(std::vector<std::string>& result, { UNORDERED_SET<std::string> uniqueOptions; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "COMPILE_OPTIONS", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "COMPILE_OPTIONS", CM_NULLPTR, CM_NULLPTR); std::vector<std::string> debugProperties; const char* debugProp = @@ -2536,8 +2539,8 @@ void cmGeneratorTarget::GetCompileFeatures(std::vector<std::string>& result, { UNORDERED_SET<std::string> uniqueFeatures; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "COMPILE_FEATURES", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "COMPILE_FEATURES", CM_NULLPTR, CM_NULLPTR); std::vector<std::string> debugProperties; const char* debugProp = @@ -2586,8 +2589,8 @@ void cmGeneratorTarget::GetCompileDefinitions( { UNORDERED_SET<std::string> uniqueOptions; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "COMPILE_DEFINITIONS", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "COMPILE_DEFINITIONS", CM_NULLPTR, CM_NULLPTR); std::vector<std::string> debugProperties; const char* debugProp = @@ -2625,7 +2628,7 @@ void cmGeneratorTarget::GetCompileDefinitions( } case cmPolicies::OLD: { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(configProp); linkInterfaceCompileDefinitionsEntries.push_back( new cmGeneratorTarget::TargetPropertyEntry(cge)); @@ -2793,8 +2796,8 @@ void cmGeneratorTarget::GetLibraryNames(std::string& name, std::string& soName, this->IsFrameworkOnApple()) { // Versioning is supported only for shared libraries and modules, // and then only when the platform supports an soname flag. - version = 0; - soversion = 0; + version = CM_NULLPTR; + soversion = CM_NULLPTR; } if (version && !soversion) { // The soversion must be set if the library version is set. Use @@ -2868,7 +2871,7 @@ void cmGeneratorTarget::GetExecutableNames(std::string& name, const char* version = this->GetProperty("VERSION"); if (this->GetType() != cmState::EXECUTABLE || this->Makefile->IsOn("XCODE")) { - version = 0; + version = CM_NULLPTR; } #endif @@ -2968,7 +2971,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, : this->GetProperty("PREFIX")); const char* targetSuffix = (implib ? this->GetProperty("IMPORT_SUFFIX") : this->GetProperty("SUFFIX")); - const char* configPostfix = 0; + const char* configPostfix = CM_NULLPTR; if (!config.empty()) { std::string configProp = cmSystemTools::UpperCase(config); configProp += "_POSTFIX"; @@ -2976,7 +2979,7 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, // Mac application bundles and frameworks have no postfix. if (configPostfix && (this->IsAppBundleOnApple() || this->IsFrameworkOnApple())) { - configPostfix = 0; + configPostfix = CM_NULLPTR; } } const char* prefixVar = this->Target->GetPrefixVariableInternal(implib); @@ -3010,14 +3013,14 @@ void cmGeneratorTarget::GetFullNameInternal(const std::string& config, fw_prefix = this->GetOutputName(config, false); fw_prefix += ".framework/"; targetPrefix = fw_prefix.c_str(); - targetSuffix = 0; + targetSuffix = CM_NULLPTR; } if (this->IsCFBundleOnApple()) { fw_prefix = this->GetCFBundleDirectory(config, false); fw_prefix += "/"; targetPrefix = fw_prefix.c_str(); - targetSuffix = 0; + targetSuffix = CM_NULLPTR; } // Begin the final name with the prefix. @@ -3266,7 +3269,7 @@ const char* getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt, switch (t) { case BoolType: assert(0 && "String compatibility check function called for boolean"); - return 0; + return CM_NULLPTR; case StringType: return tgt->GetLinkInterfaceDependentStringProperty(prop, config); case NumberMinType: @@ -3275,7 +3278,7 @@ const char* getLinkInterfaceDependentProperty(cmGeneratorTarget const* tgt, return tgt->GetLinkInterfaceDependentNumberMaxProperty(prop, config); } assert(0 && "Unreachable!"); - return 0; + return CM_NULLPTR; } template <typename PropertyType> @@ -3313,7 +3316,7 @@ void checkPropertyConsistency(cmGeneratorTarget const* depender, } if (emitted.insert(*pi).second) { getLinkInterfaceDependentProperty<PropertyType>(depender, *pi, config, t, - 0); + CM_NULLPTR); if (cmSystemTools::GetErrorOccuredFlag()) { return; } @@ -3391,24 +3394,25 @@ void cmGeneratorTarget::CheckPropertyCompatibility( } checkPropertyConsistency<bool>(this, li->Target, strBool, emittedBools, - config, BoolType, 0); + config, BoolType, CM_NULLPTR); if (cmSystemTools::GetErrorOccuredFlag()) { return; } - checkPropertyConsistency<const char*>( - this, li->Target, strString, emittedStrings, config, StringType, 0); + checkPropertyConsistency<const char*>(this, li->Target, strString, + emittedStrings, config, StringType, + CM_NULLPTR); if (cmSystemTools::GetErrorOccuredFlag()) { return; } checkPropertyConsistency<const char*>(this, li->Target, strNumMin, emittedMinNumbers, config, - NumberMinType, 0); + NumberMinType, CM_NULLPTR); if (cmSystemTools::GetErrorOccuredFlag()) { return; } checkPropertyConsistency<const char*>(this, li->Target, strNumMax, emittedMaxNumbers, config, - NumberMaxType, 0); + NumberMaxType, CM_NULLPTR); if (cmSystemTools::GetErrorOccuredFlag()) { return; } @@ -3541,7 +3545,7 @@ std::pair<bool, const char*> consistentStringProperty(const char* lhs, const char* rhs) { const bool b = strcmp(lhs, rhs) == 0; - return std::make_pair(b, b ? lhs : 0); + return std::make_pair(b, b ? lhs : CM_NULLPTR); } std::pair<bool, const char*> consistentNumberProperty(const char* lhs, @@ -3550,7 +3554,7 @@ std::pair<bool, const char*> consistentNumberProperty(const char* lhs, { char* pEnd; - const char* const null_ptr = 0; + const char* const null_ptr = CM_NULLPTR; long lnum = strtol(lhs, &pEnd, 0); if (pEnd == lhs || *pEnd != '\0' || errno == ERANGE) { @@ -3584,7 +3588,7 @@ std::pair<bool, const char*> consistentProperty(const char* lhs, return std::make_pair(true, lhs); } - const char* const null_ptr = 0; + const char* const null_ptr = CM_NULLPTR; switch (t) { case BoolType: @@ -3755,28 +3759,28 @@ bool cmGeneratorTarget::GetLinkInterfaceDependentBoolProperty( const std::string& p, const std::string& config) const { return checkInterfacePropertyCompatibility<bool>(this, p, config, "FALSE", - BoolType, 0); + BoolType, CM_NULLPTR); } const char* cmGeneratorTarget::GetLinkInterfaceDependentStringProperty( const std::string& p, const std::string& config) const { return checkInterfacePropertyCompatibility<const char*>( - this, p, config, "empty", StringType, 0); + this, p, config, "empty", StringType, CM_NULLPTR); } const char* cmGeneratorTarget::GetLinkInterfaceDependentNumberMinProperty( const std::string& p, const std::string& config) const { return checkInterfacePropertyCompatibility<const char*>( - this, p, config, "empty", NumberMinType, 0); + this, p, config, "empty", NumberMinType, CM_NULLPTR); } const char* cmGeneratorTarget::GetLinkInterfaceDependentNumberMaxProperty( const std::string& p, const std::string& config) const { return checkInterfacePropertyCompatibility<const char*>( - this, p, config, "empty", NumberMaxType, 0); + this, p, config, "empty", NumberMaxType, CM_NULLPTR); } cmComputeLinkInformation* cmGeneratorTarget::GetLinkInformation( @@ -3791,7 +3795,7 @@ cmComputeLinkInformation* cmGeneratorTarget::GetLinkInformation( new cmComputeLinkInformation(this, config); if (!info || !info->Compute()) { delete info; - info = 0; + info = CM_NULLPTR; } // Store the information for this configuration. @@ -3968,14 +3972,15 @@ void cmGeneratorTarget::ExpandLinkItems( std::vector<cmLinkItem>& items, bool& hadHeadSensitiveCondition) const { cmGeneratorExpression ge; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), prop, 0, 0); + cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), prop, CM_NULLPTR, + CM_NULLPTR); // The $<LINK_ONLY> expression may be in a link interface to specify private // link dependencies that are otherwise excluded from usage requirements. if (usage_requirements_only) { dagChecker.SetTransitivePropertiesOnly(); } std::vector<std::string> libs; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(value); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(value); cmSystemTools::ExpandListArgument(cge->Evaluate(this->LocalGenerator, config, false, headTarget, this, &dagChecker), @@ -3996,7 +4001,7 @@ cmLinkInterface const* cmGeneratorTarget::GetLinkInterface( // export symbols. if (this->GetType() == cmState::EXECUTABLE && !this->IsExecutableWithExports()) { - return 0; + return CM_NULLPTR; } // Lookup any existing link interface for this configuration. @@ -4020,7 +4025,7 @@ cmLinkInterface const* cmGeneratorTarget::GetLinkInterface( } } - return iface.Exists ? &iface : 0; + return iface.Exists ? &iface : CM_NULLPTR; } void cmGeneratorTarget::ComputeLinkInterface( @@ -4112,7 +4117,7 @@ const cmLinkInterfaceLibraries* cmGeneratorTarget::GetLinkInterfaceLibraries( // export symbols. if (this->GetType() == cmState::EXECUTABLE && !this->IsExecutableWithExports()) { - return 0; + return CM_NULLPTR; } // Lookup any existing link interface for this configuration. @@ -4135,7 +4140,7 @@ const cmLinkInterfaceLibraries* cmGeneratorTarget::GetLinkInterfaceLibraries( usage_requirements_only); } - return iface.Exists ? &iface : 0; + return iface.Exists ? &iface : CM_NULLPTR; } std::string cmGeneratorTarget::GetDirectory(const std::string& config, @@ -4164,7 +4169,7 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo( { // There is no output information for imported targets. if (this->IsImported()) { - return 0; + return CM_NULLPTR; } // Only libraries and executables have well-defined output files. @@ -4174,7 +4179,7 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo( msg += " which has type "; msg += cmState::GetTargetTypeName(this->GetType()); this->LocalGenerator->IssueMessage(cmake::INTERNAL_ERROR, msg); - return 0; + return CM_NULLPTR; } // Lookup/compute/cache the output information for this configuration. @@ -4205,7 +4210,7 @@ cmGeneratorTarget::OutputInfo const* cmGeneratorTarget::GetOutputInfo( cmake::FATAL_ERROR, "Target '" + this->GetName() + "' OUTPUT_DIRECTORY depends on itself.", this->GetBacktrace()); - return 0; + return CM_NULLPTR; } return &i->second; } @@ -4219,7 +4224,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, // Look for a target property defining the target output directory // based on the target type. std::string targetTypeName = this->GetOutputTargetType(implib); - const char* propertyName = 0; + const char* propertyName = CM_NULLPTR; std::string propertyNameStr = targetTypeName; if (!propertyNameStr.empty()) { propertyNameStr += "_OUTPUT_DIRECTORY"; @@ -4228,7 +4233,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, // Check for a per-configuration output directory target property. std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; + const char* configProp = CM_NULLPTR; std::string configPropStr = targetTypeName; if (!configPropStr.empty()) { configPropStr += "_OUTPUT_DIRECTORY_"; @@ -4240,8 +4245,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, if (const char* config_outdir = this->GetProperty(configProp)) { // Use the user-specified per-configuration output directory. cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(config_outdir); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(config_outdir); out = cge->Evaluate(this->LocalGenerator, config); // Skip per-configuration subdirectory. @@ -4249,7 +4253,7 @@ bool cmGeneratorTarget::ComputeOutputDir(const std::string& config, } else if (const char* outdir = this->GetProperty(propertyName)) { // Use the user-specified output directory. cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(outdir); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(outdir); out = cge->Evaluate(this->LocalGenerator, config); // Skip per-configuration subdirectory if the value contained a @@ -4296,7 +4300,7 @@ bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind, { // Look for a target property defining the target output directory // based on the target type. - const char* propertyName = 0; + const char* propertyName = CM_NULLPTR; std::string propertyNameStr = kind; if (!propertyNameStr.empty()) { propertyNameStr += "_OUTPUT_DIRECTORY"; @@ -4306,7 +4310,7 @@ bool cmGeneratorTarget::ComputePDBOutputDir(const std::string& kind, // Check for a per-configuration output directory target property. std::string configUpper = cmSystemTools::UpperCase(conf); - const char* configProp = 0; + const char* configProp = CM_NULLPTR; std::string configPropStr = kind; if (!configPropStr.empty()) { configPropStr += "_OUTPUT_DIRECTORY_"; @@ -4364,7 +4368,7 @@ void cmGeneratorTarget::ComputeLinkInterfaceLibraries( // An explicit list of interface libraries may be set for shared // libraries and executables that export symbols. - const char* explicitLibraries = 0; + const char* explicitLibraries = CM_NULLPTR; std::string linkIfaceProp; if (this->GetPolicyStatusCMP0022() != cmPolicies::OLD && this->GetPolicyStatusCMP0022() != cmPolicies::WARN) { @@ -4490,7 +4494,7 @@ const cmLinkInterface* cmGeneratorTarget::GetImportLinkInterface( { cmGeneratorTarget::ImportInfo const* info = this->GetImportInfo(config); if (!info) { - return 0; + return CM_NULLPTR; } std::string CONFIG = cmSystemTools::UpperCase(config); @@ -4526,7 +4530,7 @@ cmGeneratorTarget::ImportInfo const* cmGeneratorTarget::GetImportInfo( { // There is no imported information for non-imported targets. if (!this->IsImported()) { - return 0; + return CM_NULLPTR; } // Lookup/compute/cache the import information for this @@ -4552,7 +4556,7 @@ cmGeneratorTarget::ImportInfo const* cmGeneratorTarget::GetImportInfo( // If the location is empty then the target is not available for // this configuration. if (i->second.Location.empty() && i->second.ImportLibrary.empty()) { - return 0; + return CM_NULLPTR; } // Return the import information. @@ -4569,8 +4573,8 @@ void cmGeneratorTarget::ComputeImportInfo(std::string const& desired_config, // Initialize members. info.NoSOName = false; - const char* loc = 0; - const char* imp = 0; + const char* loc = CM_NULLPTR; + const char* imp = CM_NULLPTR; std::string suffix; if (!this->Target->GetMappedConfig(desired_config, &loc, &imp, suffix)) { return; @@ -4712,7 +4716,7 @@ const cmLinkImplementation* cmGeneratorTarget::GetLinkImplementation( { // There is no link implementation for imported targets. if (this->IsImported()) { - return 0; + return CM_NULLPTR; } std::string CONFIG = cmSystemTools::UpperCase(config); @@ -4941,7 +4945,7 @@ cmGeneratorTarget::GetLinkImplementationLibrariesInternal( { // There is no link implementation for imported targets. if (this->IsImported()) { - return 0; + return CM_NULLPTR; } // Populate the link implementation libraries for this configuration. @@ -4981,10 +4985,10 @@ void cmGeneratorTarget::ComputeLinkImplementationLibraries( end = entryRange.end(); le != end; ++le, ++btIt) { std::vector<std::string> llibs; - cmGeneratorExpressionDAGChecker dagChecker(this->GetName(), - "LINK_LIBRARIES", 0, 0); + cmGeneratorExpressionDAGChecker dagChecker( + this->GetName(), "LINK_LIBRARIES", CM_NULLPTR, CM_NULLPTR); cmGeneratorExpression ge(*btIt); - cmsys::auto_ptr<cmCompiledGeneratorExpression> const cge = ge.Parse(*le); + CM_AUTO_PTR<cmCompiledGeneratorExpression> const cge = ge.Parse(*le); std::string const evaluated = cge->Evaluate(this->LocalGenerator, config, false, head, &dagChecker); cmSystemTools::ExpandListArgument(evaluated, llibs); @@ -5075,7 +5079,7 @@ cmGeneratorTarget* cmGeneratorTarget::FindTargetToLink( // within the project. if (tgt && tgt->GetType() == cmState::EXECUTABLE && !tgt->IsExecutableWithExports()) { - tgt = 0; + tgt = CM_NULLPTR; } if (tgt && tgt->GetType() == cmState::OBJECT_LIBRARY) { @@ -5089,7 +5093,7 @@ cmGeneratorTarget* cmGeneratorTarget::FindTargetToLink( "with the ENABLE_EXPORTS property set."; cmake* cm = this->LocalGenerator->GetCMakeInstance(); cm->IssueMessage(cmake::FATAL_ERROR, e.str(), this->GetBacktrace()); - tgt = 0; + tgt = CM_NULLPTR; } return tgt; diff --git a/Source/cmGeneratorTarget.h b/Source/cmGeneratorTarget.h index 2ee9bef..f9987aa 100644 --- a/Source/cmGeneratorTarget.h +++ b/Source/cmGeneratorTarget.h @@ -215,7 +215,7 @@ public: bool contentOnly = true) const; /** @return the mac content directory for this target. */ - std::string GetMacContentDirectory(const std::string& config = 0, + std::string GetMacContentDirectory(const std::string& config = CM_NULLPTR, bool implib = false) const; cmTarget* Target; @@ -402,7 +402,7 @@ public: { SourceFileFlags() : Type(SourceFileTypeNormal) - , MacFolder(0) + , MacFolder(CM_NULLPTR) { } SourceFileFlags(SourceFileFlags const& r) @@ -453,7 +453,7 @@ public: /** Convert the given GNU import library name (.dll.a) to a name with a new extension (.lib or ${CMAKE_IMPORT_LIBRARY_SUFFIX}). */ bool GetImplibGNUtoMS(std::string const& gnuName, std::string& out, - const char* newExt = 0) const; + const char* newExt = CM_NULLPTR) const; bool IsExecutableWithExports() const; diff --git a/Source/cmGetCMakePropertyCommand.cxx b/Source/cmGetCMakePropertyCommand.cxx index 331aab9..c89d030 100644 --- a/Source/cmGetCMakePropertyCommand.cxx +++ b/Source/cmGetCMakePropertyCommand.cxx @@ -42,7 +42,7 @@ bool cmGetCMakePropertyCommand::InitialPass( this->Makefile->GetGlobalGenerator()->GetInstallComponents(); output = cmJoin(*components, ";"); } else { - const char* prop = 0; + const char* prop = CM_NULLPTR; if (!args[1].empty()) { prop = this->Makefile->GetState()->GetGlobalProperty(args[1]); } diff --git a/Source/cmGetCMakePropertyCommand.h b/Source/cmGetCMakePropertyCommand.h index fd247e8..7df9cc1 100644 --- a/Source/cmGetCMakePropertyCommand.h +++ b/Source/cmGetCMakePropertyCommand.h @@ -17,24 +17,24 @@ class cmGetCMakePropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmGetCMakePropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetCMakePropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_cmake_property"; } + std::string GetName() const CM_OVERRIDE { return "get_cmake_property"; } cmTypeMacro(cmGetCMakePropertyCommand, cmCommand); }; diff --git a/Source/cmGetDirectoryPropertyCommand.cxx b/Source/cmGetDirectoryPropertyCommand.cxx index 1b5bcc9..a331e78 100644 --- a/Source/cmGetDirectoryPropertyCommand.cxx +++ b/Source/cmGetDirectoryPropertyCommand.cxx @@ -73,7 +73,7 @@ bool cmGetDirectoryPropertyCommand::InitialPass( return true; } - const char* prop = 0; + const char* prop = CM_NULLPTR; if (!i->empty()) { if (*i == "DEFINITIONS") { switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0059)) { diff --git a/Source/cmGetDirectoryPropertyCommand.h b/Source/cmGetDirectoryPropertyCommand.h index 97394ec..1be9aa4 100644 --- a/Source/cmGetDirectoryPropertyCommand.h +++ b/Source/cmGetDirectoryPropertyCommand.h @@ -17,24 +17,24 @@ class cmGetDirectoryPropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmGetDirectoryPropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetDirectoryPropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_directory_property"; } + std::string GetName() const CM_OVERRIDE { return "get_directory_property"; } cmTypeMacro(cmGetDirectoryPropertyCommand, cmCommand); diff --git a/Source/cmGetFilenameComponentCommand.h b/Source/cmGetFilenameComponentCommand.h index a114b3d..d8609fe 100644 --- a/Source/cmGetFilenameComponentCommand.h +++ b/Source/cmGetFilenameComponentCommand.h @@ -26,24 +26,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmGetFilenameComponentCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetFilenameComponentCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_filename_component"; } + std::string GetName() const CM_OVERRIDE { return "get_filename_component"; } cmTypeMacro(cmGetFilenameComponentCommand, cmCommand); }; diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx index 06f7504..854fdb8 100644 --- a/Source/cmGetPropertyCommand.cxx +++ b/Source/cmGetPropertyCommand.cxx @@ -248,15 +248,14 @@ bool cmGetPropertyCommand::HandleTargetMode() return false; } - if (this->PropertyName == "ALIASED_TARGET") { - if (this->Makefile->IsAlias(this->Name)) { - if (cmTarget* target = this->Makefile->FindTargetToUse(this->Name)) { + if (cmTarget* target = this->Makefile->FindTargetToUse(this->Name)) { + if (this->PropertyName == "ALIASED_TARGET") { + if (this->Makefile->IsAlias(this->Name)) { return this->StoreResult(target->GetName().c_str()); + } else { + return this->StoreResult((this->Variable + "-NOTFOUND").c_str()); } } - return this->StoreResult((this->Variable + "-NOTFOUND").c_str()); - } - if (cmTarget* target = this->Makefile->FindTargetToUse(this->Name)) { return this->StoreResult( target->GetProperty(this->PropertyName, this->Makefile)); } else { @@ -323,7 +322,7 @@ bool cmGetPropertyCommand::HandleCacheMode() return false; } - const char* value = 0; + const char* value = CM_NULLPTR; if (this->Makefile->GetState()->GetCacheEntryValue(this->Name)) { value = this->Makefile->GetState()->GetCacheEntryProperty( this->Name, this->PropertyName); @@ -347,7 +346,7 @@ bool cmGetPropertyCommand::HandleInstallMode() std::string value; bool isSet = file->GetProperty(this->PropertyName, value); - return this->StoreResult(isSet ? value.c_str() : 0); + return this->StoreResult(isSet ? value.c_str() : CM_NULLPTR); } else { std::ostringstream e; e << "given INSTALL name that could not be found or created: " diff --git a/Source/cmGetPropertyCommand.h b/Source/cmGetPropertyCommand.h index aeed01d..558226b 100644 --- a/Source/cmGetPropertyCommand.h +++ b/Source/cmGetPropertyCommand.h @@ -19,24 +19,24 @@ class cmGetPropertyCommand : public cmCommand public: cmGetPropertyCommand(); - virtual cmCommand* Clone() { return new cmGetPropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetPropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_property"; } + std::string GetName() const CM_OVERRIDE { return "get_property"; } cmTypeMacro(cmGetPropertyCommand, cmCommand); diff --git a/Source/cmGetSourceFilePropertyCommand.cxx b/Source/cmGetSourceFilePropertyCommand.cxx index e64befe..7b30a7d 100644 --- a/Source/cmGetSourceFilePropertyCommand.cxx +++ b/Source/cmGetSourceFilePropertyCommand.cxx @@ -34,7 +34,7 @@ bool cmGetSourceFilePropertyCommand::InitialPass( this->Makefile->AddDefinition(var, sf->GetLanguage().c_str()); return true; } - const char* prop = 0; + const char* prop = CM_NULLPTR; if (!args[2].empty()) { prop = sf->GetPropertyForUser(args[2]); } diff --git a/Source/cmGetSourceFilePropertyCommand.h b/Source/cmGetSourceFilePropertyCommand.h index 06f582f..2d2477c 100644 --- a/Source/cmGetSourceFilePropertyCommand.h +++ b/Source/cmGetSourceFilePropertyCommand.h @@ -17,19 +17,22 @@ class cmGetSourceFilePropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmGetSourceFilePropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetSourceFilePropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_source_file_property"; } + std::string GetName() const CM_OVERRIDE + { + return "get_source_file_property"; + } cmTypeMacro(cmGetSourceFilePropertyCommand, cmCommand); }; diff --git a/Source/cmGetTargetPropertyCommand.cxx b/Source/cmGetTargetPropertyCommand.cxx index dded9f7..073cf32 100644 --- a/Source/cmGetTargetPropertyCommand.cxx +++ b/Source/cmGetTargetPropertyCommand.cxx @@ -24,22 +24,18 @@ bool cmGetTargetPropertyCommand::InitialPass( std::string prop; bool prop_exists = false; - if (args[2] == "ALIASED_TARGET") { - if (this->Makefile->IsAlias(targetName)) { - if (cmTarget* target = this->Makefile->FindTargetToUse(targetName)) { - prop = target->GetName(); + if (cmTarget* tgt = this->Makefile->FindTargetToUse(targetName)) { + if (args[2] == "ALIASED_TARGET") { + if (this->Makefile->IsAlias(targetName)) { + prop = tgt->GetName(); + prop_exists = true; + } + } else if (!args[2].empty()) { + const char* prop_cstr = tgt->GetProperty(args[2], this->Makefile); + if (prop_cstr) { + prop = prop_cstr; prop_exists = true; } - } - } else if (cmTarget* tgt = this->Makefile->FindTargetToUse(targetName)) { - cmTarget& target = *tgt; - const char* prop_cstr = 0; - if (!args[2].empty()) { - prop_cstr = target.GetProperty(args[2], this->Makefile); - } - if (prop_cstr) { - prop = prop_cstr; - prop_exists = true; } } else { bool issueMessage = false; diff --git a/Source/cmGetTargetPropertyCommand.h b/Source/cmGetTargetPropertyCommand.h index 9a1e18e..3e0fe36 100644 --- a/Source/cmGetTargetPropertyCommand.h +++ b/Source/cmGetTargetPropertyCommand.h @@ -17,19 +17,19 @@ class cmGetTargetPropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmGetTargetPropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetTargetPropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_target_property"; } + std::string GetName() const CM_OVERRIDE { return "get_target_property"; } cmTypeMacro(cmGetTargetPropertyCommand, cmCommand); }; diff --git a/Source/cmGetTestPropertyCommand.cxx b/Source/cmGetTestPropertyCommand.cxx index 6599021..5eaf872 100644 --- a/Source/cmGetTestPropertyCommand.cxx +++ b/Source/cmGetTestPropertyCommand.cxx @@ -27,7 +27,7 @@ bool cmGetTestPropertyCommand::InitialPass( std::string var = args[2]; cmTest* test = this->Makefile->GetTest(testName); if (test) { - const char* prop = 0; + const char* prop = CM_NULLPTR; if (!args[1].empty()) { prop = test->GetProperty(args[1]); } diff --git a/Source/cmGetTestPropertyCommand.h b/Source/cmGetTestPropertyCommand.h index fc281c4..e419c98 100644 --- a/Source/cmGetTestPropertyCommand.h +++ b/Source/cmGetTestPropertyCommand.h @@ -17,19 +17,19 @@ class cmGetTestPropertyCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmGetTestPropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmGetTestPropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "get_test_property"; } + std::string GetName() const CM_OVERRIDE { return "get_test_property"; } cmTypeMacro(cmGetTestPropertyCommand, cmCommand); }; diff --git a/Source/cmGlobalCommonGenerator.h b/Source/cmGlobalCommonGenerator.h index 7bb0e55..a48ff4f 100644 --- a/Source/cmGlobalCommonGenerator.h +++ b/Source/cmGlobalCommonGenerator.h @@ -21,7 +21,7 @@ class cmGlobalCommonGenerator : public cmGlobalGenerator { public: cmGlobalCommonGenerator(cmake* cm); - ~cmGlobalCommonGenerator(); + ~cmGlobalCommonGenerator() CM_OVERRIDE; }; #endif diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx index 536c5d2..3ec16c0 100644 --- a/Source/cmGlobalGenerator.cxx +++ b/Source/cmGlobalGenerator.cxx @@ -81,9 +81,9 @@ cmGlobalGenerator::cmGlobalGenerator(cmake* cm) // how long to let try compiles run this->TryCompileTimeout = 0; - this->ExtraGenerator = 0; - this->CurrentMakefile = 0; - this->TryCompileOuterMakefile = 0; + this->ExtraGenerator = CM_NULLPTR; + this->CurrentMakefile = CM_NULLPTR; + this->TryCompileOuterMakefile = CM_NULLPTR; this->ConfigureDoneCMP0026AndCMP0024 = false; @@ -242,7 +242,7 @@ bool cmGlobalGenerator::GenerateImportFile(const std::string& file) } delete it->second; - it->second = 0; + it->second = CM_NULLPTR; this->BuildExportSets.erase(it); return result; } @@ -1081,7 +1081,7 @@ void cmGlobalGenerator::Configure() std::ostringstream msg; if (cmSystemTools::GetErrorOccuredFlag()) { msg << "Configuring incomplete, errors occurred!"; - const char* logs[] = { "CMakeOutput.log", "CMakeError.log", 0 }; + const char* logs[] = { "CMakeOutput.log", "CMakeError.log", CM_NULLPTR }; for (const char** log = logs; *log; ++log) { std::string f = this->CMakeInstance->GetHomeOutputDirectory(); f += this->CMakeInstance->GetCMakeFilesDirectory(); @@ -1128,7 +1128,7 @@ cmExportBuildFileGenerator* cmGlobalGenerator::GetExportedTargetsFile( { std::map<std::string, cmExportBuildFileGenerator*>::const_iterator it = this->BuildExportSets.find(filename); - return it == this->BuildExportSets.end() ? 0 : it->second; + return it == this->BuildExportSets.end() ? CM_NULLPTR : it->second; } void cmGlobalGenerator::AddCMP0042WarnTarget(const std::string& target) @@ -1269,7 +1269,7 @@ void cmGlobalGenerator::Generate() "Generating", (static_cast<float>(i) + 1.0f) / static_cast<float>(this->LocalGenerators.size())); } - this->SetCurrentMakefile(0); + this->SetCurrentMakefile(CM_NULLPTR); if (!this->GenerateCPackPropertiesFile()) { this->GetCMakeInstance()->IssueMessage( @@ -1291,7 +1291,7 @@ void cmGlobalGenerator::Generate() this->WriteSummary(); - if (this->ExtraGenerator != 0) { + if (this->ExtraGenerator != CM_NULLPTR) { this->ExtraGenerator->Generate(); } @@ -1698,7 +1698,8 @@ int cmGlobalGenerator::Build(const std::string&, const std::string& bindir, output += "\n"; if (!cmSystemTools::RunSingleCommand(cleanCommand, outputPtr, outputPtr, - &retVal, 0, outputflag, timeout)) { + &retVal, CM_NULLPTR, outputflag, + timeout)) { cmSystemTools::SetRunCommandHideConsole(hideconsole); cmSystemTools::Error("Generator: execution of make clean failed."); output += *outputPtr; @@ -1718,7 +1719,8 @@ int cmGlobalGenerator::Build(const std::string&, const std::string& bindir, output += "\n"; if (!cmSystemTools::RunSingleCommand(makeCommand, outputPtr, outputPtr, - &retVal, 0, outputflag, timeout)) { + &retVal, CM_NULLPTR, outputflag, + timeout)) { cmSystemTools::SetRunCommandHideConsole(hideconsole); cmSystemTools::Error( "Generator: execution of make failed. Make command was: ", @@ -1945,7 +1947,7 @@ cmMakefile* cmGlobalGenerator::FindMakefile(const std::string& start_dir) const return *it; } } - return 0; + return CM_NULLPTR; } ///! Find a local generator by its startdirectory @@ -1960,7 +1962,7 @@ cmLocalGenerator* cmGlobalGenerator::FindLocalGenerator( return *it; } } - return 0; + return CM_NULLPTR; } void cmGlobalGenerator::AddAlias(const std::string& name, @@ -1994,7 +1996,7 @@ cmTarget* cmGlobalGenerator::FindTargetImpl(std::string const& name) const if (i != this->TargetSearchIndex.end()) { return i->second; } - return 0; + return CM_NULLPTR; } cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl( @@ -2005,7 +2007,7 @@ cmGeneratorTarget* cmGlobalGenerator::FindGeneratorTargetImpl( if (i != this->GeneratorTargetSearchIndex.end()) { return i->second; } - return 0; + return CM_NULLPTR; } cmTarget* cmGlobalGenerator::FindTarget(const std::string& name, @@ -2135,7 +2137,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) cpackCommandLines.push_back(singleLine); (*targets)[this->GetTestTargetName()] = this->CreateGlobalTarget(this->GetTestTargetName(), "Running tests...", - &cpackCommandLines, depends, 0, + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); } @@ -2156,7 +2158,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) cpackCommandLines.push_back(singleLine); (*targets)[editCacheTargetName] = this->CreateGlobalTarget( editCacheTargetName, "Running CMake cache editor...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ true); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); } else { singleLine.push_back(cmSystemTools::GetCMakeCommand()); singleLine.push_back("-E"); @@ -2165,7 +2167,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) cpackCommandLines.push_back(singleLine); (*targets)[editCacheTargetName] = this->CreateGlobalTarget( editCacheTargetName, "No interactive CMake dialog available...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ false); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ false); } } @@ -2182,7 +2184,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) cpackCommandLines.push_back(singleLine); (*targets)[rebuildCacheTargetName] = this->CreateGlobalTarget( rebuildCacheTargetName, "Running CMake to regenerate build system...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ true); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); } // Install @@ -2208,7 +2210,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) singleLine.push_back(ostr.str()); (*targets)["list_install_components"] = this->CreateGlobalTarget( "list_install_components", ostr.str().c_str(), &cpackCommandLines, - depends, 0, /*uses_terminal*/ false); + depends, CM_NULLPTR, /*uses_terminal*/ false); } std::string cmd = cmSystemTools::GetCMakeCommand(); cpackCommandLines.erase(cpackCommandLines.begin(), @@ -2249,7 +2251,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) cpackCommandLines.push_back(singleLine); (*targets)[this->GetInstallTargetName()] = this->CreateGlobalTarget( this->GetInstallTargetName(), "Install the project...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ true); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); // install_local if (const char* install_local = this->GetInstallLocalTargetName()) { @@ -2263,12 +2265,12 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) (*targets)[install_local] = this->CreateGlobalTarget( install_local, "Installing only the local directory...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ true); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); } // install_strip const char* install_strip = this->GetInstallStripTargetName(); - if ((install_strip != 0) && (mf->IsSet("CMAKE_STRIP"))) { + if ((install_strip != CM_NULLPTR) && (mf->IsSet("CMAKE_STRIP"))) { cmCustomCommandLine stripCmdLine = singleLine; stripCmdLine.insert(stripCmdLine.begin() + 1, @@ -2279,7 +2281,7 @@ void cmGlobalGenerator::CreateDefaultGlobalTargets(cmTargets* targets) (*targets)[install_strip] = this->CreateGlobalTarget( install_strip, "Installing the project stripped...", - &cpackCommandLines, depends, 0, /*uses_terminal*/ true); + &cpackCommandLines, depends, CM_NULLPTR, /*uses_terminal*/ true); } } } @@ -2327,8 +2329,8 @@ cmTarget cmGlobalGenerator::CreateGlobalTarget( std::vector<std::string> no_byproducts; std::vector<std::string> no_depends; // Store the custom command in the target. - cmCustomCommand cc(0, no_outputs, no_byproducts, no_depends, *commandLines, - 0, workingDirectory); + cmCustomCommand cc(CM_NULLPTR, no_outputs, no_byproducts, no_depends, + *commandLines, CM_NULLPTR, workingDirectory); cc.SetUsesTerminal(uses_terminal); target.AddPostBuildCommand(cc); target.SetProperty("EchoString", message); @@ -2406,7 +2408,7 @@ void cmGlobalGenerator::SetExternalMakefileProjectGenerator( cmExternalMakefileProjectGenerator* extraGenerator) { this->ExtraGenerator = extraGenerator; - if (this->ExtraGenerator != 0) { + if (this->ExtraGenerator != CM_NULLPTR) { this->ExtraGenerator->SetGlobalGenerator(this); } } diff --git a/Source/cmGlobalGenerator.h b/Source/cmGlobalGenerator.h index 68ff042..089a637 100644 --- a/Source/cmGlobalGenerator.h +++ b/Source/cmGlobalGenerator.h @@ -25,7 +25,7 @@ #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cmFileLockPool.h" -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP #include <unordered_map> #else #include <cmsys/hash_map.hxx> @@ -277,15 +277,15 @@ public: virtual const char* GetAllTargetName() const { return "ALL_BUILD"; } virtual const char* GetInstallTargetName() const { return "INSTALL"; } - virtual const char* GetInstallLocalTargetName() const { return 0; } - virtual const char* GetInstallStripTargetName() const { return 0; } - virtual const char* GetPreinstallTargetName() const { return 0; } + virtual const char* GetInstallLocalTargetName() const { return CM_NULLPTR; } + virtual const char* GetInstallStripTargetName() const { return CM_NULLPTR; } + virtual const char* GetPreinstallTargetName() const { return CM_NULLPTR; } virtual const char* GetTestTargetName() const { return "RUN_TESTS"; } virtual const char* GetPackageTargetName() const { return "PACKAGE"; } - virtual const char* GetPackageSourceTargetName() const { return 0; } - virtual const char* GetEditCacheTargetName() const { return 0; } - virtual const char* GetRebuildCacheTargetName() const { return 0; } - virtual const char* GetCleanTargetName() const { return 0; } + virtual const char* GetPackageSourceTargetName() const { return CM_NULLPTR; } + virtual const char* GetEditCacheTargetName() const { return CM_NULLPTR; } + virtual const char* GetRebuildCacheTargetName() const { return CM_NULLPTR; } + virtual const char* GetCleanTargetName() const { return CM_NULLPTR; } // Lookup edit_cache target command preferred by this generator. virtual std::string GetEditCacheCommand() const { return ""; } @@ -433,7 +433,7 @@ protected: private: #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, cmTarget*> TargetMap; typedef std::unordered_map<std::string, cmGeneratorTarget*> GeneratorTargetMap; @@ -503,7 +503,7 @@ private: void ClearGeneratorMembers(); - virtual const char* GetBuildIgnoreErrorsFlag() const { return 0; } + virtual const char* GetBuildIgnoreErrorsFlag() const { return CM_NULLPTR; } // Cache directory content and target files to be built. struct DirectoryContent diff --git a/Source/cmGlobalGeneratorFactory.h b/Source/cmGlobalGeneratorFactory.h index 7d4fe2c..6787519 100644 --- a/Source/cmGlobalGeneratorFactory.h +++ b/Source/cmGlobalGeneratorFactory.h @@ -48,29 +48,29 @@ class cmGlobalGeneratorSimpleFactory : public cmGlobalGeneratorFactory { public: /** Create a GlobalGenerator */ - virtual cmGlobalGenerator* CreateGlobalGenerator(const std::string& name, - cmake* cm) const + cmGlobalGenerator* CreateGlobalGenerator(const std::string& name, + cmake* cm) const CM_OVERRIDE { if (name != T::GetActualName()) { - return 0; + return CM_NULLPTR; } return new T(cm); } /** Get the documentation entry for this factory */ - virtual void GetDocumentation(cmDocumentationEntry& entry) const + void GetDocumentation(cmDocumentationEntry& entry) const CM_OVERRIDE { T::GetDocumentation(entry); } /** Get the names of the current registered generators */ - virtual void GetGenerators(std::vector<std::string>& names) const + void GetGenerators(std::vector<std::string>& names) const CM_OVERRIDE { names.push_back(T::GetActualName()); } /** Determine whether or not this generator supports toolsets */ - virtual bool SupportsToolset() const { return T::SupportsToolset(); } + bool SupportsToolset() const CM_OVERRIDE { return T::SupportsToolset(); } }; #endif diff --git a/Source/cmGlobalKdevelopGenerator.cxx b/Source/cmGlobalKdevelopGenerator.cxx index 68a2538..bbd6baa 100644 --- a/Source/cmGlobalKdevelopGenerator.cxx +++ b/Source/cmGlobalKdevelopGenerator.cxx @@ -111,13 +111,13 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile( // make sure the file is part of this source tree if ((tmp[0] != '/') && (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) == - 0)) { + CM_NULLPTR)) { files.insert(tmp); tmp = cmSystemTools::GetFilenameName(tmp); // add all files which dont match the default // */CMakeLists.txt;*cmake; to the file pattern if ((tmp != "CMakeLists.txt") && - (strstr(tmp.c_str(), ".cmake") == 0)) { + (strstr(tmp.c_str(), ".cmake") == CM_NULLPTR)) { cmakeFilePattern += tmp + ";"; } } @@ -142,7 +142,7 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile( if ((tmp[0] != '/') && (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) == - 0) && + CM_NULLPTR) && (cmSystemTools::GetFilenameExtension(tmp) != ".moc")) { files.insert(tmp); @@ -166,7 +166,7 @@ bool cmGlobalKdevelopGenerator::CreateFilelistFile( cmSystemTools::ReplaceString(tmp, projectDir.c_str(), ""); if ((tmp[0] != '/') && (strstr(tmp.c_str(), cmake::GetCMakeFilesDirectoryPostSlash()) == - 0)) { + CM_NULLPTR)) { files.insert(tmp); } } @@ -296,12 +296,12 @@ void cmGlobalKdevelopGenerator::MergeProjectFiles( it != lines.end(); it++) { const char* line = (*it).c_str(); // skip these tags as they are always replaced - if ((strstr(line, "<projectdirectory>") != 0) || - (strstr(line, "<projectmanagement>") != 0) || - (strstr(line, "<absoluteprojectpath>") != 0) || - (strstr(line, "<filelistdirectory>") != 0) || - (strstr(line, "<buildtool>") != 0) || - (strstr(line, "<builddir>") != 0)) { + if ((strstr(line, "<projectdirectory>") != CM_NULLPTR) || + (strstr(line, "<projectmanagement>") != CM_NULLPTR) || + (strstr(line, "<absoluteprojectpath>") != CM_NULLPTR) || + (strstr(line, "<filelistdirectory>") != CM_NULLPTR) || + (strstr(line, "<buildtool>") != CM_NULLPTR) || + (strstr(line, "<builddir>") != CM_NULLPTR)) { continue; } diff --git a/Source/cmGlobalKdevelopGenerator.h b/Source/cmGlobalKdevelopGenerator.h index 315e38e..c61cafb 100644 --- a/Source/cmGlobalKdevelopGenerator.h +++ b/Source/cmGlobalKdevelopGenerator.h @@ -33,7 +33,7 @@ class cmGlobalKdevelopGenerator : public cmExternalMakefileProjectGenerator public: cmGlobalKdevelopGenerator(); - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmGlobalKdevelopGenerator::GetActualName(); } @@ -43,10 +43,10 @@ public: return new cmGlobalKdevelopGenerator; } /** Get the documentation entry for this generator. */ - virtual void GetDocumentation(cmDocumentationEntry& entry, - const std::string& fullName) const; + void GetDocumentation(cmDocumentationEntry& entry, + const std::string& fullName) const CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; private: /*** Create the foo.kdevelop.filelist file, return false if it doesn't diff --git a/Source/cmGlobalNinjaGenerator.cxx b/Source/cmGlobalNinjaGenerator.cxx index 3aec630..91f08e6 100644 --- a/Source/cmGlobalNinjaGenerator.cxx +++ b/Source/cmGlobalNinjaGenerator.cxx @@ -443,9 +443,9 @@ void cmGlobalNinjaGenerator::WriteDefault(std::ostream& os, cmGlobalNinjaGenerator::cmGlobalNinjaGenerator(cmake* cm) : cmGlobalCommonGenerator(cm) - , BuildFileStream(0) - , RulesFileStream(0) - , CompileCommandsStream(0) + , BuildFileStream(CM_NULLPTR) + , RulesFileStream(CM_NULLPTR) + , CompileCommandsStream(CM_NULLPTR) , Rules() , AllDependencies() , UsingGCCOnWindows(false) @@ -531,8 +531,8 @@ void cmGlobalNinjaGenerator::FindMakeProgram(cmMakefile* mf) command.push_back(this->NinjaCommand); command.push_back("--version"); std::string version; - cmSystemTools::RunSingleCommand(command, &version, 0, 0, 0, - cmSystemTools::OUTPUT_NONE); + cmSystemTools::RunSingleCommand(command, &version, CM_NULLPTR, CM_NULLPTR, + CM_NULLPTR, cmSystemTools::OUTPUT_NONE); this->NinjaVersion = cmSystemTools::TrimWhitespace(version); } } @@ -676,7 +676,7 @@ void cmGlobalNinjaGenerator::CloseBuildFileStream() { if (this->BuildFileStream) { delete this->BuildFileStream; - this->BuildFileStream = 0; + this->BuildFileStream = CM_NULLPTR; } else { cmSystemTools::Error("Build file stream was not open."); } @@ -717,7 +717,7 @@ void cmGlobalNinjaGenerator::CloseRulesFileStream() { if (this->RulesFileStream) { delete this->RulesFileStream; - this->RulesFileStream = 0; + this->RulesFileStream = CM_NULLPTR; } else { cmSystemTools::Error("Rules file stream was not open."); } @@ -805,7 +805,7 @@ void cmGlobalNinjaGenerator::CloseCompileCommandsStream() if (this->CompileCommandsStream) { *this->CompileCommandsStream << "\n]"; delete this->CompileCommandsStream; - this->CompileCommandsStream = 0; + this->CompileCommandsStream = CM_NULLPTR; } } @@ -914,7 +914,7 @@ void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias, // Mark the target's outputs as ambiguous to ensure that no other target uses // the output as an alias. for (cmNinjaDeps::iterator i = outputs.begin(); i != outputs.end(); ++i) { - TargetAliases[*i] = 0; + TargetAliases[*i] = CM_NULLPTR; } // Insert the alias into the map. If the alias was already present in the @@ -922,7 +922,7 @@ void cmGlobalNinjaGenerator::AddTargetAlias(const std::string& alias, std::pair<TargetAliasMap::iterator, bool> newAlias = TargetAliases.insert(std::make_pair(buildAlias, target)); if (newAlias.second && newAlias.first->second != target) { - newAlias.first->second = 0; + newAlias.first->second = CM_NULLPTR; } } diff --git a/Source/cmGlobalNinjaGenerator.h b/Source/cmGlobalNinjaGenerator.h index 6d9bfe8..69ec6ca 100644 --- a/Source/cmGlobalNinjaGenerator.h +++ b/Source/cmGlobalNinjaGenerator.h @@ -93,7 +93,7 @@ public: const cmNinjaDeps& orderOnlyDeps, const cmNinjaVars& variables, const std::string& rspfile = std::string(), - int cmdLineLimit = 0, bool* usedResponseFile = 0); + int cmdLineLimit = 0, bool* usedResponseFile = CM_NULLPTR); /** * Helper to write a build statement with the special 'phony' rule. @@ -161,11 +161,11 @@ public: return new cmGlobalGeneratorSimpleFactory<cmGlobalNinjaGenerator>(); } - virtual ~cmGlobalNinjaGenerator() {} + ~cmGlobalNinjaGenerator() CM_OVERRIDE {} - virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf); + cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) CM_OVERRIDE; - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmGlobalNinjaGenerator::GetActualName(); } @@ -174,39 +174,44 @@ public: static void GetDocumentation(cmDocumentationEntry& entry); - virtual void EnableLanguage(std::vector<std::string> const& languages, - cmMakefile* mf, bool optional); + void EnableLanguage(std::vector<std::string> const& languages, + cmMakefile* mf, bool optional) CM_OVERRIDE; - virtual void GenerateBuildCommand( - std::vector<std::string>& makeCommand, const std::string& makeProgram, - const std::string& projectName, const std::string& projectDir, - const std::string& targetName, const std::string& config, bool fast, - bool verbose, - std::vector<std::string> const& makeOptions = std::vector<std::string>()); + void GenerateBuildCommand(std::vector<std::string>& makeCommand, + const std::string& makeProgram, + const std::string& projectName, + const std::string& projectDir, + const std::string& targetName, + const std::string& config, bool fast, bool verbose, + std::vector<std::string> const& makeOptions = + std::vector<std::string>()) CM_OVERRIDE; // Setup target names - virtual const char* GetAllTargetName() const { return "all"; } - virtual const char* GetInstallTargetName() const { return "install"; } - virtual const char* GetInstallLocalTargetName() const + const char* GetAllTargetName() const CM_OVERRIDE { return "all"; } + const char* GetInstallTargetName() const CM_OVERRIDE { return "install"; } + const char* GetInstallLocalTargetName() const CM_OVERRIDE { return "install/local"; } - virtual const char* GetInstallStripTargetName() const + const char* GetInstallStripTargetName() const CM_OVERRIDE { return "install/strip"; } - virtual const char* GetTestTargetName() const { return "test"; } - virtual const char* GetPackageTargetName() const { return "package"; } - virtual const char* GetPackageSourceTargetName() const + const char* GetTestTargetName() const CM_OVERRIDE { return "test"; } + const char* GetPackageTargetName() const CM_OVERRIDE { return "package"; } + const char* GetPackageSourceTargetName() const CM_OVERRIDE { return "package_source"; } - virtual const char* GetEditCacheTargetName() const { return "edit_cache"; } - virtual const char* GetRebuildCacheTargetName() const + const char* GetEditCacheTargetName() const CM_OVERRIDE + { + return "edit_cache"; + } + const char* GetRebuildCacheTargetName() const CM_OVERRIDE { return "rebuild_cache"; } - virtual const char* GetCleanTargetName() const { return "clean"; } + const char* GetCleanTargetName() const CM_OVERRIDE { return "clean"; } cmGeneratedFileStream* GetBuildFileStream() const { @@ -307,7 +312,7 @@ public: void AddTargetAlias(const std::string& alias, cmGeneratorTarget* target); - virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const; + void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const CM_OVERRIDE; // Ninja generator uses 'deps' and 'msvc_deps_prefix' introduced in 1.3 static std::string RequiredNinjaVersion() { return "1.3"; } @@ -319,13 +324,13 @@ public: void StripNinjaOutputPathPrefixAsSuffix(std::string& path); protected: - virtual void Generate(); + void Generate() CM_OVERRIDE; - virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; } + bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const CM_OVERRIDE { return true; } private: - virtual std::string GetEditCacheCommand() const; - virtual void FindMakeProgram(cmMakefile* mf); + std::string GetEditCacheCommand() const CM_OVERRIDE; + void FindMakeProgram(cmMakefile* mf) CM_OVERRIDE; void OpenBuildFileStream(); void CloseBuildFileStream(); diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx index cc5d1ba..f115ecb 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.cxx +++ b/Source/cmGlobalUnixMakefileGenerator3.cxx @@ -32,7 +32,7 @@ cmGlobalUnixMakefileGenerator3::cmGlobalUnixMakefileGenerator3(cmake* cm) #else this->UseLinkScript = true; #endif - this->CommandDatabase = NULL; + this->CommandDatabase = CM_NULLPTR; this->IncludeDirective = "include"; this->DefineWindowsNULL = false; @@ -155,10 +155,10 @@ void cmGlobalUnixMakefileGenerator3::Generate() this->WriteMainMakefile2(); this->WriteMainCMakefile(); - if (this->CommandDatabase != NULL) { + if (this->CommandDatabase != CM_NULLPTR) { *this->CommandDatabase << std::endl << "]"; delete this->CommandDatabase; - this->CommandDatabase = NULL; + this->CommandDatabase = CM_NULLPTR; } } @@ -166,7 +166,7 @@ void cmGlobalUnixMakefileGenerator3::AddCXXCompileCommand( const std::string& sourceFile, const std::string& workingDirectory, const std::string& compileCommand) { - if (this->CommandDatabase == NULL) { + if (this->CommandDatabase == CM_NULLPTR) { std::string commandDatabaseName = std::string(this->GetCMakeInstance()->GetHomeOutputDirectory()) + "/compile_commands.json"; diff --git a/Source/cmGlobalUnixMakefileGenerator3.h b/Source/cmGlobalUnixMakefileGenerator3.h index f951b2a..98969ff 100644 --- a/Source/cmGlobalUnixMakefileGenerator3.h +++ b/Source/cmGlobalUnixMakefileGenerator3.h @@ -63,7 +63,7 @@ public: } ///! Get the name for the generator. - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmGlobalUnixMakefileGenerator3::GetActualName(); } @@ -78,23 +78,23 @@ public: /** Get the documentation entry for this generator. */ static void GetDocumentation(cmDocumentationEntry& entry); - virtual cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf); + cmLocalGenerator* CreateLocalGenerator(cmMakefile* mf) CM_OVERRIDE; /** * Try to determine system information such as shared library * extension, pthreads, byte order etc. */ - virtual void EnableLanguage(std::vector<std::string> const& languages, - cmMakefile*, bool optional); + void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*, + bool optional) CM_OVERRIDE; - virtual void Configure(); + void Configure() CM_OVERRIDE; /** * Generate the all required files for building this project/tree. This * basically creates a series of LocalGenerators for each directory and * requests that they Generate. */ - virtual void Generate(); + void Generate() CM_OVERRIDE; void WriteMainCMakefileLanguageRules(cmGeneratedFileStream& cmakefileStream, std::vector<cmLocalGenerator*>&); @@ -116,12 +116,14 @@ public: std::string GetEmptyRuleHackDepends() { return this->EmptyRuleHackDepends; } // change the build command for speed - virtual void GenerateBuildCommand( - std::vector<std::string>& makeCommand, const std::string& makeProgram, - const std::string& projectName, const std::string& projectDir, - const std::string& targetName, const std::string& config, bool fast, - bool verbose, - std::vector<std::string> const& makeOptions = std::vector<std::string>()); + void GenerateBuildCommand(std::vector<std::string>& makeCommand, + const std::string& makeProgram, + const std::string& projectName, + const std::string& projectDir, + const std::string& targetName, + const std::string& config, bool fast, bool verbose, + std::vector<std::string> const& makeOptions = + std::vector<std::string>()) CM_OVERRIDE; /** Record per-target progress information. */ void RecordTargetProgress(cmMakefileTargetGenerator* tg); @@ -136,7 +138,7 @@ public: /** Does the make tool tolerate .DELETE_ON_ERROR? */ virtual bool AllowDeleteOnError() const { return true; } - virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const; + void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const CM_OVERRIDE; std::string IncludeDirective; bool DefineWindowsNULL; @@ -163,19 +165,37 @@ protected: bool NeedRequiresStep(cmGeneratorTarget const*); // Target name hooks for superclass. - const char* GetAllTargetName() const { return "all"; } - const char* GetInstallTargetName() const { return "install"; } - const char* GetInstallLocalTargetName() const { return "install/local"; } - const char* GetInstallStripTargetName() const { return "install/strip"; } - const char* GetPreinstallTargetName() const { return "preinstall"; } - const char* GetTestTargetName() const { return "test"; } - const char* GetPackageTargetName() const { return "package"; } - const char* GetPackageSourceTargetName() const { return "package_source"; } - const char* GetEditCacheTargetName() const { return "edit_cache"; } - const char* GetRebuildCacheTargetName() const { return "rebuild_cache"; } - const char* GetCleanTargetName() const { return "clean"; } - - virtual bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const { return true; } + const char* GetAllTargetName() const CM_OVERRIDE { return "all"; } + const char* GetInstallTargetName() const CM_OVERRIDE { return "install"; } + const char* GetInstallLocalTargetName() const CM_OVERRIDE + { + return "install/local"; + } + const char* GetInstallStripTargetName() const CM_OVERRIDE + { + return "install/strip"; + } + const char* GetPreinstallTargetName() const CM_OVERRIDE + { + return "preinstall"; + } + const char* GetTestTargetName() const CM_OVERRIDE { return "test"; } + const char* GetPackageTargetName() const CM_OVERRIDE { return "package"; } + const char* GetPackageSourceTargetName() const CM_OVERRIDE + { + return "package_source"; + } + const char* GetEditCacheTargetName() const CM_OVERRIDE + { + return "edit_cache"; + } + const char* GetRebuildCacheTargetName() const CM_OVERRIDE + { + return "rebuild_cache"; + } + const char* GetCleanTargetName() const CM_OVERRIDE { return "clean"; } + + bool CheckALLOW_DUPLICATE_CUSTOM_TARGETS() const CM_OVERRIDE { return true; } // Some make programs (Borland) do not keep a rule if there are no // dependencies or commands. This is a problem for creating rules @@ -214,13 +234,13 @@ protected: cmGeneratedFileStream* CommandDatabase; private: - virtual const char* GetBuildIgnoreErrorsFlag() const { return "-i"; } - virtual std::string GetEditCacheCommand() const; + const char* GetBuildIgnoreErrorsFlag() const CM_OVERRIDE { return "-i"; } + std::string GetEditCacheCommand() const CM_OVERRIDE; std::map<cmState::Snapshot, std::set<cmGeneratorTarget const*>, cmState::Snapshot::StrictWeakOrder> DirectoryTargetsMap; - virtual void InitializeProgressMarks(); + void InitializeProgressMarks() CM_OVERRIDE; }; #endif diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx index a33bd8b..262909f 100644 --- a/Source/cmGlobalVisualStudio7Generator.cxx +++ b/Source/cmGlobalVisualStudio7Generator.cxx @@ -674,7 +674,7 @@ std::set<std::string> cmGlobalVisualStudio7Generator::IsPartOfDefaultBuild( target->Target->GetMakefile()->GetDefinition( "CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD"); cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(propertyValue); if (cmSystemTools::IsOn( cge->Evaluate(target->GetLocalGenerator(), *i))) { diff --git a/Source/cmGlobalWatcomWMakeGenerator.h b/Source/cmGlobalWatcomWMakeGenerator.h index 3954907..bc0d786 100644 --- a/Source/cmGlobalWatcomWMakeGenerator.h +++ b/Source/cmGlobalWatcomWMakeGenerator.h @@ -28,7 +28,7 @@ public: return new cmGlobalGeneratorSimpleFactory<cmGlobalWatcomWMakeGenerator>(); } ///! Get the name for the generator. - virtual std::string GetName() const + std::string GetName() const CM_OVERRIDE { return cmGlobalWatcomWMakeGenerator::GetActualName(); } @@ -41,11 +41,11 @@ public: * Try to determine system information such as shared library * extension, pthreads, byte order etc. */ - virtual void EnableLanguage(std::vector<std::string> const& languages, - cmMakefile*, bool optional); + void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*, + bool optional) CM_OVERRIDE; - virtual bool AllowNotParallel() const { return false; } - virtual bool AllowDeleteOnError() const { return false; } + bool AllowNotParallel() const CM_OVERRIDE { return false; } + bool AllowDeleteOnError() const CM_OVERRIDE { return false; } }; #endif diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx index e82cb16..e65ca09 100644 --- a/Source/cmGlobalXCodeGenerator.cxx +++ b/Source/cmGlobalXCodeGenerator.cxx @@ -24,7 +24,7 @@ #include "cmXCodeObject.h" #include "cmake.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> #if defined(CMAKE_BUILD_WITH_CMAKE) #include "cmXMLParser.h" @@ -175,7 +175,7 @@ cmGlobalGenerator* cmGlobalXCodeGenerator::Factory::CreateGlobalGenerator( parser.ParseFile( "/Developer/Applications/Xcode.app/Contents/version.plist"); } - cmsys::auto_ptr<cmGlobalXCodeGenerator> gg( + CM_AUTO_PTR<cmGlobalXCodeGenerator> gg( new cmGlobalXCodeGenerator(cm, parser.Version)); if (gg->XcodeVersion == 20) { cmSystemTools::Message("Xcode 2.0 not really supported by cmake, " diff --git a/Source/cmGraphVizWriter.cxx b/Source/cmGraphVizWriter.cxx index 3963cf8..adb9936 100644 --- a/Source/cmGraphVizWriter.cxx +++ b/Source/cmGraphVizWriter.cxx @@ -64,9 +64,8 @@ void cmGraphVizWriter::ReadSettings(const char* settingsFileName, cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator ggi(&cm); - cmsys::auto_ptr<cmMakefile> mf( - new cmMakefile(&ggi, cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lg(ggi.CreateLocalGenerator(mf.get())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&ggi, cm.GetCurrentSnapshot())); + CM_AUTO_PTR<cmLocalGenerator> lg(ggi.CreateLocalGenerator(mf.get())); const char* inFileName = settingsFileName; @@ -149,7 +148,7 @@ void cmGraphVizWriter::WriteTargetDependersFiles(const char* fileName) for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) { - if (ptrIt->second == NULL) { + if (ptrIt->second == CM_NULLPTR) { continue; } @@ -193,7 +192,7 @@ void cmGraphVizWriter::WritePerTargetFiles(const char* fileName) for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) { - if (ptrIt->second == NULL) { + if (ptrIt->second == CM_NULLPTR) { continue; } @@ -239,7 +238,7 @@ void cmGraphVizWriter::WriteGlobalFile(const char* fileName) for (std::map<std::string, const cmGeneratorTarget*>::const_iterator ptrIt = this->TargetPtrs.begin(); ptrIt != this->TargetPtrs.end(); ++ptrIt) { - if (ptrIt->second == NULL) { + if (ptrIt->second == CM_NULLPTR) { continue; } @@ -278,7 +277,7 @@ void cmGraphVizWriter::WriteConnections( this->WriteNode(targetName, targetPtrIt->second, insertedNodes, str); - if (targetPtrIt->second == NULL) // it's an external library + if (targetPtrIt->second == CM_NULLPTR) // it's an external library { return; } @@ -329,7 +328,7 @@ void cmGraphVizWriter::WriteDependerConnections( this->WriteNode(targetName, targetPtrIt->second, insertedNodes, str); - if (targetPtrIt->second == NULL) // it's an external library + if (targetPtrIt->second == CM_NULLPTR) // it's an external library { return; } @@ -340,7 +339,7 @@ void cmGraphVizWriter::WriteDependerConnections( for (std::map<std::string, const cmGeneratorTarget*>::const_iterator dependerIt = this->TargetPtrs.begin(); dependerIt != this->TargetPtrs.end(); ++dependerIt) { - if (dependerIt->second == NULL) { + if (dependerIt->second == CM_NULLPTR) { continue; } @@ -468,7 +467,7 @@ int cmGraphVizWriter::CollectAllExternalLibs(int cnt) std::ostringstream ostr; ostr << this->GraphNodePrefix << cnt++; this->TargetNamesNodes[libName] = ostr.str(); - this->TargetPtrs[libName] = NULL; + this->TargetPtrs[libName] = CM_NULLPTR; // str << " \"" << ostr << "\" [ label=\"" << libName // << "\" shape=\"ellipse\"];" << std::endl; } diff --git a/Source/cmHexFileConverter.cxx b/Source/cmHexFileConverter.cxx index 9609e95..34fd626 100644 --- a/Source/cmHexFileConverter.cxx +++ b/Source/cmHexFileConverter.cxx @@ -28,7 +28,7 @@ static bool cm_IsHexChar(char c) static unsigned int ChompStrlen(const char* line) { - if (line == 0) { + if (line == CM_NULLPTR) { return 0; } unsigned int length = static_cast<unsigned int>(strlen(line)); @@ -144,7 +144,7 @@ cmHexFileConverter::FileType cmHexFileConverter::DetermineFileType( { char buf[1024]; FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb"); - if (inFile == 0) { + if (inFile == CM_NULLPTR) { return Binary; } @@ -193,11 +193,11 @@ bool cmHexFileConverter::TryConvert(const char* inFileName, // try to open the file FILE* inFile = cmsys::SystemTools::Fopen(inFileName, "rb"); FILE* outFile = cmsys::SystemTools::Fopen(outFileName, "wb"); - if ((inFile == 0) || (outFile == 0)) { - if (inFile != 0) { + if ((inFile == CM_NULLPTR) || (outFile == CM_NULLPTR)) { + if (inFile != CM_NULLPTR) { fclose(inFile); } - if (outFile != 0) { + if (outFile != CM_NULLPTR) { fclose(outFile); } return false; @@ -206,7 +206,7 @@ bool cmHexFileConverter::TryConvert(const char* inFileName, // convert them line by line bool success = false; char buf[1024]; - while (fgets(buf, 1024, inFile) != 0) { + while (fgets(buf, 1024, inFile) != CM_NULLPTR) { if (type == MotorolaSrec) { success = ConvertMotorolaSrecLine(buf, outFile); } else if (type == IntelHex) { diff --git a/Source/cmIfCommand.cxx b/Source/cmIfCommand.cxx index cb5ba76..dd04136 100644 --- a/Source/cmIfCommand.cxx +++ b/Source/cmIfCommand.cxx @@ -46,8 +46,7 @@ bool cmIfFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, // if this is the endif for this if statement, then start executing if (!this->ScopeDepth) { // Remove the function blocker for this scope or bail. - cmsys::auto_ptr<cmFunctionBlocker> fb( - mf.RemoveFunctionBlocker(this, lff)); + CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff)); if (!fb.get()) { return false; } diff --git a/Source/cmIfCommand.h b/Source/cmIfCommand.h index 54200df..f1f979d 100644 --- a/Source/cmIfCommand.h +++ b/Source/cmIfCommand.h @@ -24,10 +24,10 @@ public: this->HasRun = false; this->ScopeDepth = 0; } - virtual ~cmIfFunctionBlocker() {} - virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, - cmExecutionStatus&); - virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf); + ~cmIfFunctionBlocker() CM_OVERRIDE {} + bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; + bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE; std::vector<cmListFileArgument> Args; std::vector<cmListFileFunction> Functions; @@ -43,20 +43,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmIfCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmIfCommand; } /** * This overrides the default InvokeInitialPass implementation. * It records the arguments before expansion. */ - virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&); + bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -64,12 +65,12 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "if"; } + std::string GetName() const CM_OVERRIDE { return "if"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } // Filter the given variable definition based on policy CMP0054. static const char* GetDefinitionIfUnquoted( diff --git a/Source/cmIncludeCommand.cxx b/Source/cmIncludeCommand.cxx index cb9b74d..360ebeb 100644 --- a/Source/cmIncludeCommand.cxx +++ b/Source/cmIncludeCommand.cxx @@ -77,7 +77,7 @@ bool cmIncludeCommand::InitialPass(std::vector<std::string> const& args, cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator(); if (gg->IsExportedTargetsFile(fname_abs)) { - const char* modal = 0; + const char* modal = CM_NULLPTR; std::ostringstream e; cmake::MessageType messageType = cmake::AUTHOR_WARNING; diff --git a/Source/cmIncludeCommand.h b/Source/cmIncludeCommand.h index e319dbd..365a830 100644 --- a/Source/cmIncludeCommand.h +++ b/Source/cmIncludeCommand.h @@ -26,24 +26,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmIncludeCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmIncludeCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "include"; } + std::string GetName() const CM_OVERRIDE { return "include"; } cmTypeMacro(cmIncludeCommand, cmCommand); }; diff --git a/Source/cmIncludeDirectoryCommand.h b/Source/cmIncludeDirectoryCommand.h index 952294b..25be709 100644 --- a/Source/cmIncludeDirectoryCommand.h +++ b/Source/cmIncludeDirectoryCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmIncludeDirectoryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmIncludeDirectoryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "include_directories"; } + std::string GetName() const CM_OVERRIDE { return "include_directories"; } cmTypeMacro(cmIncludeDirectoryCommand, cmCommand); diff --git a/Source/cmIncludeExternalMSProjectCommand.h b/Source/cmIncludeExternalMSProjectCommand.h index 999eb9e..8cda7b9 100644 --- a/Source/cmIncludeExternalMSProjectCommand.h +++ b/Source/cmIncludeExternalMSProjectCommand.h @@ -27,19 +27,25 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmIncludeExternalMSProjectCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmIncludeExternalMSProjectCommand; + } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "include_external_msproject"; } + std::string GetName() const CM_OVERRIDE + { + return "include_external_msproject"; + } cmTypeMacro(cmIncludeExternalMSProjectCommand, cmCommand); }; diff --git a/Source/cmIncludeRegularExpressionCommand.h b/Source/cmIncludeRegularExpressionCommand.h index 1071a7a..52fdff0 100644 --- a/Source/cmIncludeRegularExpressionCommand.h +++ b/Source/cmIncludeRegularExpressionCommand.h @@ -26,19 +26,25 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmIncludeRegularExpressionCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmIncludeRegularExpressionCommand; + } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "include_regular_expression"; } + std::string GetName() const CM_OVERRIDE + { + return "include_regular_expression"; + } cmTypeMacro(cmIncludeRegularExpressionCommand, cmCommand); }; diff --git a/Source/cmInstallCommand.cxx b/Source/cmInstallCommand.cxx index e9de8df..86ab85a 100644 --- a/Source/cmInstallCommand.cxx +++ b/Source/cmInstallCommand.cxx @@ -186,7 +186,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) cmCommandArgumentsHelper argHelper; cmCommandArgumentGroup group; - cmCAStringVector genericArgVector(&argHelper, 0); + cmCAStringVector genericArgVector(&argHelper, CM_NULLPTR); cmCAStringVector archiveArgVector(&argHelper, "ARCHIVE", &group); cmCAStringVector libraryArgVector(&argHelper, "LIBRARY", &group); cmCAStringVector runtimeArgVector(&argHelper, "RUNTIME", &group); @@ -197,10 +197,10 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) &group); cmCAStringVector publicHeaderArgVector(&argHelper, "PUBLIC_HEADER", &group); cmCAStringVector resourceArgVector(&argHelper, "RESOURCE", &group); - genericArgVector.Follows(0); + genericArgVector.Follows(CM_NULLPTR); group.Follows(&genericArgVector); - argHelper.Parse(&args, 0); + argHelper.Parse(&args, CM_NULLPTR); // now parse the generic args (i.e. the ones not specialized on LIBRARY/ // ARCHIVE, RUNTIME etc. (see above) @@ -210,7 +210,7 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) cmCAStringVector targetList(&genericArgs.Parser, "TARGETS"); cmCAString exports(&genericArgs.Parser, "EXPORT", &genericArgs.ArgumentGroup); - targetList.Follows(0); + targetList.Follows(CM_NULLPTR); genericArgs.ArgumentGroup.Follows(&targetList); genericArgs.Parse(&genericArgVector.GetVector(), &unknownArgs); bool success = genericArgs.Finalize(); @@ -373,14 +373,14 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) ti != targets.end(); ++ti) { // Handle each target type. cmTarget& target = *(*ti); - cmInstallTargetGenerator* archiveGenerator = 0; - cmInstallTargetGenerator* libraryGenerator = 0; - cmInstallTargetGenerator* runtimeGenerator = 0; - cmInstallTargetGenerator* frameworkGenerator = 0; - cmInstallTargetGenerator* bundleGenerator = 0; - cmInstallFilesGenerator* privateHeaderGenerator = 0; - cmInstallFilesGenerator* publicHeaderGenerator = 0; - cmInstallFilesGenerator* resourceGenerator = 0; + cmInstallTargetGenerator* archiveGenerator = CM_NULLPTR; + cmInstallTargetGenerator* libraryGenerator = CM_NULLPTR; + cmInstallTargetGenerator* runtimeGenerator = CM_NULLPTR; + cmInstallTargetGenerator* frameworkGenerator = CM_NULLPTR; + cmInstallTargetGenerator* bundleGenerator = CM_NULLPTR; + cmInstallFilesGenerator* privateHeaderGenerator = CM_NULLPTR; + cmInstallFilesGenerator* publicHeaderGenerator = CM_NULLPTR; + cmInstallFilesGenerator* resourceGenerator = CM_NULLPTR; // Track whether this is a namelink-only rule. bool namelinkOnly = false; @@ -407,7 +407,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) runtimeGenerator = CreateInstallTargetGenerator(target, runtimeArgs, false); } - if ((archiveGenerator == 0) && (runtimeGenerator == 0)) { + if ((archiveGenerator == CM_NULLPTR) && + (runtimeGenerator == CM_NULLPTR)) { this->SetError("Library TARGETS given no DESTINATION!"); return false; } @@ -621,14 +622,15 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args) } // Keep track of whether we're installing anything in each category - installsArchive = installsArchive || archiveGenerator != 0; - installsLibrary = installsLibrary || libraryGenerator != 0; - installsRuntime = installsRuntime || runtimeGenerator != 0; - installsFramework = installsFramework || frameworkGenerator != 0; - installsBundle = installsBundle || bundleGenerator != 0; + installsArchive = installsArchive || archiveGenerator != CM_NULLPTR; + installsLibrary = installsLibrary || libraryGenerator != CM_NULLPTR; + installsRuntime = installsRuntime || runtimeGenerator != CM_NULLPTR; + installsFramework = installsFramework || frameworkGenerator != CM_NULLPTR; + installsBundle = installsBundle || bundleGenerator != CM_NULLPTR; installsPrivateHeader = - installsPrivateHeader || privateHeaderGenerator != 0; - installsPublicHeader = installsPublicHeader || publicHeaderGenerator != 0; + installsPrivateHeader || privateHeaderGenerator != CM_NULLPTR; + installsPublicHeader = + installsPublicHeader || publicHeaderGenerator != CM_NULLPTR; installsResource = installsResource || resourceGenerator; this->Makefile->AddInstallGenerator(archiveGenerator); @@ -704,7 +706,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args) bool programs = (args[0] == "PROGRAMS"); cmInstallCommandArguments ica(this->DefaultComponentName); cmCAStringVector files(&ica.Parser, programs ? "PROGRAMS" : "FILES"); - files.Follows(0); + files.Follows(CM_NULLPTR); ica.ArgumentGroup.Follows(&files); std::vector<std::string> unknownArgs; ica.Parse(&args, &unknownArgs); @@ -744,7 +746,7 @@ bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args) for (std::vector<std::string>::const_iterator fileIt = filesVector.begin(); fileIt != filesVector.end(); ++fileIt) { if (gg->IsExportedTargetsFile(*fileIt)) { - const char* modal = 0; + const char* modal = CM_NULLPTR; std::ostringstream e; cmake::MessageType messageType = cmake::AUTHOR_WARNING; @@ -820,7 +822,7 @@ bool cmInstallCommand::HandleDirectoryMode( bool exclude_from_all = false; bool message_never = false; std::vector<std::string> dirs; - const char* destination = 0; + const char* destination = CM_NULLPTR; std::string permissions_file; std::string permissions_dir; std::vector<std::string> configurations; @@ -1103,7 +1105,7 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args) cmCAEnabler exportOld(&ica.Parser, "EXPORT_LINK_INTERFACE_LIBRARIES", &ica.ArgumentGroup); cmCAString filename(&ica.Parser, "FILE", &ica.ArgumentGroup); - exp.Follows(0); + exp.Follows(CM_NULLPTR); ica.ArgumentGroup.Follows(&exp); std::vector<std::string> unknownArgs; diff --git a/Source/cmInstallCommand.h b/Source/cmInstallCommand.h index 93aca45..3718ad5 100644 --- a/Source/cmInstallCommand.h +++ b/Source/cmInstallCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmInstallCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmInstallCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "install"; } + std::string GetName() const CM_OVERRIDE { return "install"; } cmTypeMacro(cmInstallCommand, cmCommand); diff --git a/Source/cmInstallCommandArguments.cxx b/Source/cmInstallCommandArguments.cxx index 57e37a3..312c50e 100644 --- a/Source/cmInstallCommandArguments.cxx +++ b/Source/cmInstallCommandArguments.cxx @@ -17,7 +17,7 @@ const char* cmInstallCommandArguments::PermissionsTable[] = { "OWNER_READ", "OWNER_WRITE", "OWNER_EXECUTE", "GROUP_READ", "GROUP_WRITE", "GROUP_EXECUTE", "WORLD_READ", "WORLD_WRITE", - "WORLD_EXECUTE", "SETUID", "SETGID", 0 + "WORLD_EXECUTE", "SETUID", "SETGID", CM_NULLPTR }; const std::string cmInstallCommandArguments::EmptyString; @@ -35,7 +35,7 @@ cmInstallCommandArguments::cmInstallCommandArguments( , Optional(&Parser, "OPTIONAL", &ArgumentGroup) , NamelinkOnly(&Parser, "NAMELINK_ONLY", &ArgumentGroup) , NamelinkSkip(&Parser, "NAMELINK_SKIP", &ArgumentGroup) - , GenericArguments(0) + , GenericArguments(CM_NULLPTR) , DefaultComponentName(defaultComponent) { } @@ -45,7 +45,7 @@ const std::string& cmInstallCommandArguments::GetDestination() const if (!this->DestinationString.empty()) { return this->DestinationString; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetDestination(); } return this->EmptyString; @@ -56,7 +56,7 @@ const std::string& cmInstallCommandArguments::GetComponent() const if (!this->Component.GetString().empty()) { return this->Component.GetString(); } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetComponent(); } if (!this->DefaultComponentName.empty()) { @@ -71,7 +71,7 @@ const std::string& cmInstallCommandArguments::GetRename() const if (!this->Rename.GetString().empty()) { return this->Rename.GetString(); } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetRename(); } return this->EmptyString; @@ -82,7 +82,7 @@ const std::string& cmInstallCommandArguments::GetPermissions() const if (!this->PermissionsString.empty()) { return this->PermissionsString; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetPermissions(); } return this->EmptyString; @@ -93,7 +93,7 @@ bool cmInstallCommandArguments::GetOptional() const if (this->Optional.IsEnabled()) { return true; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetOptional(); } return false; @@ -104,7 +104,7 @@ bool cmInstallCommandArguments::GetExcludeFromAll() const if (this->ExcludeFromAll.IsEnabled()) { return true; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetExcludeFromAll(); } return false; @@ -115,7 +115,7 @@ bool cmInstallCommandArguments::GetNamelinkOnly() const if (this->NamelinkOnly.IsEnabled()) { return true; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetNamelinkOnly(); } return false; @@ -126,7 +126,7 @@ bool cmInstallCommandArguments::GetNamelinkSkip() const if (this->NamelinkSkip.IsEnabled()) { return true; } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetNamelinkSkip(); } return false; @@ -138,7 +138,7 @@ const std::vector<std::string>& cmInstallCommandArguments::GetConfigurations() if (!this->Configurations.GetVector().empty()) { return this->Configurations.GetVector(); } - if (this->GenericArguments != 0) { + if (this->GenericArguments != CM_NULLPTR) { return this->GenericArguments->GetConfigurations(); } return this->Configurations.GetVector(); diff --git a/Source/cmInstallDirectoryGenerator.cxx b/Source/cmInstallDirectoryGenerator.cxx index 671ab4c..3928231 100644 --- a/Source/cmInstallDirectoryGenerator.cxx +++ b/Source/cmInstallDirectoryGenerator.cxx @@ -22,7 +22,7 @@ cmInstallDirectoryGenerator::cmInstallDirectoryGenerator( bool optional) : cmInstallGenerator(dest, configurations, component, message, exclude_from_all) - , LocalGenerator(0) + , LocalGenerator(CM_NULLPTR) , Directories(dirs) , FilePermissions(file_permissions) , DirPermissions(dir_permissions) @@ -69,7 +69,7 @@ void cmInstallDirectoryGenerator::GenerateScriptForConfig( cmGeneratorExpression ge; for (std::vector<std::string>::const_iterator i = this->Directories.begin(); i != this->Directories.end(); ++i) { - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i); cmSystemTools::ExpandListArgument( cge->Evaluate(this->LocalGenerator, config), dirs); } @@ -81,7 +81,7 @@ void cmInstallDirectoryGenerator::AddDirectoryInstallRule( std::vector<std::string> const& dirs) { // Write code to install the directories. - const char* no_rename = 0; + const char* no_rename = CM_NULLPTR; this->AddInstallRule(os, this->GetDestination(config), cmInstallType_DIRECTORY, dirs, this->Optional, this->FilePermissions.c_str(), diff --git a/Source/cmInstallDirectoryGenerator.h b/Source/cmInstallDirectoryGenerator.h index 10d7c95..93becf4 100644 --- a/Source/cmInstallDirectoryGenerator.h +++ b/Source/cmInstallDirectoryGenerator.h @@ -27,17 +27,17 @@ public: const char* component, MessageLevel message, bool exclude_from_all, const char* literal_args, bool optional = false); - virtual ~cmInstallDirectoryGenerator(); + ~cmInstallDirectoryGenerator() CM_OVERRIDE; - void Compute(cmLocalGenerator* lg); + void Compute(cmLocalGenerator* lg) CM_OVERRIDE; std::string GetDestination(std::string const& config) const; protected: - virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); - virtual void GenerateScriptForConfig(std::ostream& os, - const std::string& config, - Indent const& indent); + void GenerateScriptActions(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptForConfig(std::ostream& os, const std::string& config, + Indent const& indent) CM_OVERRIDE; void AddDirectoryInstallRule(std::ostream& os, const std::string& config, Indent const& indent, std::vector<std::string> const& dirs); diff --git a/Source/cmInstallExportGenerator.cxx b/Source/cmInstallExportGenerator.cxx index 2fef3a8..6250012 100644 --- a/Source/cmInstallExportGenerator.cxx +++ b/Source/cmInstallExportGenerator.cxx @@ -37,7 +37,7 @@ cmInstallExportGenerator::cmInstallExportGenerator( , FileName(filename) , Namespace(name_space) , ExportOld(exportOld) - , LocalGenerator(0) + , LocalGenerator(CM_NULLPTR) { this->EFGen = new cmExportInstallFileGenerator(this); exportSet->AddInstallation(this); @@ -161,8 +161,8 @@ void cmInstallExportGenerator::GenerateScriptConfigs(std::ostream& os, std::string config_test = this->CreateConfigTest(i->first); os << indent << "if(" << config_test << ")\n"; this->AddInstallRule(os, this->Destination, cmInstallType_FILES, files, - false, this->FilePermissions.c_str(), 0, 0, 0, - indent.Next()); + false, this->FilePermissions.c_str(), CM_NULLPTR, + CM_NULLPTR, CM_NULLPTR, indent.Next()); os << indent << "endif()\n"; files.clear(); } @@ -201,5 +201,6 @@ void cmInstallExportGenerator::GenerateScriptActions(std::ostream& os, std::vector<std::string> files; files.push_back(this->MainImportFile); this->AddInstallRule(os, this->Destination, cmInstallType_FILES, files, - false, this->FilePermissions.c_str(), 0, 0, 0, indent); + false, this->FilePermissions.c_str(), CM_NULLPTR, + CM_NULLPTR, CM_NULLPTR, indent); } diff --git a/Source/cmInstallExportGenerator.h b/Source/cmInstallExportGenerator.h index 256c0c9..4435f53 100644 --- a/Source/cmInstallExportGenerator.h +++ b/Source/cmInstallExportGenerator.h @@ -32,11 +32,11 @@ public: const char* component, MessageLevel message, bool exclude_from_all, const char* filename, const char* name_space, bool exportOld); - ~cmInstallExportGenerator(); + ~cmInstallExportGenerator() CM_OVERRIDE; cmExportSet* GetExportSet() { return this->ExportSet; } - void Compute(cmLocalGenerator* lg); + void Compute(cmLocalGenerator* lg) CM_OVERRIDE; cmLocalGenerator* GetLocalGenerator() const { return this->LocalGenerator; } @@ -45,9 +45,11 @@ public: std::string const& GetDestination() const { return this->Destination; } protected: - virtual void GenerateScript(std::ostream& os); - virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent); - virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); + void GenerateScript(std::ostream& os) CM_OVERRIDE; + void GenerateScriptConfigs(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptActions(std::ostream& os, + Indent const& indent) CM_OVERRIDE; void GenerateImportFile(cmExportSet const* exportSet); void GenerateImportFile(const char* config, cmExportSet const* exportSet); void ComputeTempDir(); diff --git a/Source/cmInstallFilesCommand.h b/Source/cmInstallFilesCommand.h index 0d0388a..cf2c9ff 100644 --- a/Source/cmInstallFilesCommand.h +++ b/Source/cmInstallFilesCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmInstallFilesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmInstallFilesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "install_files"; } + std::string GetName() const CM_OVERRIDE { return "install_files"; } /** * This is called at the end after all the information @@ -46,8 +46,8 @@ public: * not implement this method. At this point, reading and * writing to the cache can be done. */ - virtual void FinalPass(); - virtual bool HasFinalPass() const { return !this->IsFilesForm; } + void FinalPass() CM_OVERRIDE; + bool HasFinalPass() const CM_OVERRIDE { return !this->IsFilesForm; } cmTypeMacro(cmInstallFilesCommand, cmCommand); diff --git a/Source/cmInstallFilesGenerator.cxx b/Source/cmInstallFilesGenerator.cxx index 8c1b357..93a740c 100644 --- a/Source/cmInstallFilesGenerator.cxx +++ b/Source/cmInstallFilesGenerator.cxx @@ -23,7 +23,7 @@ cmInstallFilesGenerator::cmInstallFilesGenerator( const char* rename, bool optional) : cmInstallGenerator(dest, configurations, component, message, exclude_from_all) - , LocalGenerator(0) + , LocalGenerator(CM_NULLPTR) , Files(files) , FilePermissions(file_permissions) , Rename(rename) @@ -65,12 +65,12 @@ void cmInstallFilesGenerator::AddFilesInstallRule( std::vector<std::string> const& files) { // Write code to install the files. - const char* no_dir_permissions = 0; + const char* no_dir_permissions = CM_NULLPTR; this->AddInstallRule( os, this->GetDestination(config), (this->Programs ? cmInstallType_PROGRAMS : cmInstallType_FILES), files, this->Optional, this->FilePermissions.c_str(), no_dir_permissions, - this->Rename.c_str(), 0, indent); + this->Rename.c_str(), CM_NULLPTR, indent); } void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os, @@ -90,7 +90,7 @@ void cmInstallFilesGenerator::GenerateScriptForConfig( cmGeneratorExpression ge; for (std::vector<std::string>::const_iterator i = this->Files.begin(); i != this->Files.end(); ++i) { - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = ge.Parse(*i); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(*i); cmSystemTools::ExpandListArgument( cge->Evaluate(this->LocalGenerator, config), files); } diff --git a/Source/cmInstallFilesGenerator.h b/Source/cmInstallFilesGenerator.h index 0e738d3..5cb09f4 100644 --- a/Source/cmInstallFilesGenerator.h +++ b/Source/cmInstallFilesGenerator.h @@ -27,17 +27,17 @@ public: const char* component, MessageLevel message, bool exclude_from_all, const char* rename, bool optional = false); - virtual ~cmInstallFilesGenerator(); + ~cmInstallFilesGenerator() CM_OVERRIDE; - void Compute(cmLocalGenerator* lg); + void Compute(cmLocalGenerator* lg) CM_OVERRIDE; std::string GetDestination(std::string const& config) const; protected: - virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); - virtual void GenerateScriptForConfig(std::ostream& os, - const std::string& config, - Indent const& indent); + void GenerateScriptActions(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptForConfig(std::ostream& os, const std::string& config, + Indent const& indent) CM_OVERRIDE; void AddFilesInstallRule(std::ostream& os, std::string const& config, Indent const& indent, std::vector<std::string> const& files); diff --git a/Source/cmInstallGenerator.h b/Source/cmInstallGenerator.h index e271d53..ad9fc28 100644 --- a/Source/cmInstallGenerator.h +++ b/Source/cmInstallGenerator.h @@ -37,15 +37,14 @@ public: std::vector<std::string> const& configurations, const char* component, MessageLevel message, bool exclude_from_all); - virtual ~cmInstallGenerator(); + ~cmInstallGenerator() CM_OVERRIDE; - void AddInstallRule(std::ostream& os, std::string const& dest, - cmInstallType type, - std::vector<std::string> const& files, - bool optional = false, const char* permissions_file = 0, - const char* permissions_dir = 0, const char* rename = 0, - const char* literal_args = 0, - Indent const& indent = Indent()); + void AddInstallRule( + std::ostream& os, std::string const& dest, cmInstallType type, + std::vector<std::string> const& files, bool optional = false, + const char* permissions_file = CM_NULLPTR, + const char* permissions_dir = CM_NULLPTR, const char* rename = CM_NULLPTR, + const char* literal_args = CM_NULLPTR, Indent const& indent = Indent()); /** Get the install destination as it should appear in the installation script. */ @@ -60,7 +59,7 @@ public: virtual void Compute(cmLocalGenerator*) {} protected: - virtual void GenerateScript(std::ostream& os); + void GenerateScript(std::ostream& os) CM_OVERRIDE; std::string CreateComponentTest(const char* component, bool exclude_from_all); diff --git a/Source/cmInstallProgramsCommand.h b/Source/cmInstallProgramsCommand.h index b104c69..b56a9b1 100644 --- a/Source/cmInstallProgramsCommand.h +++ b/Source/cmInstallProgramsCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmInstallProgramsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmInstallProgramsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "install_programs"; } + std::string GetName() const CM_OVERRIDE { return "install_programs"; } /** * This is called at the end after all the information @@ -46,9 +46,9 @@ public: * not implement this method. At this point, reading and * writing to the cache can be done. */ - virtual void FinalPass(); + void FinalPass() CM_OVERRIDE; - virtual bool HasFinalPass() const { return true; } + bool HasFinalPass() const CM_OVERRIDE { return true; } cmTypeMacro(cmInstallProgramsCommand, cmCommand); diff --git a/Source/cmInstallScriptGenerator.cxx b/Source/cmInstallScriptGenerator.cxx index 1b0f1d1..76d6b71 100644 --- a/Source/cmInstallScriptGenerator.cxx +++ b/Source/cmInstallScriptGenerator.cxx @@ -15,7 +15,7 @@ cmInstallScriptGenerator::cmInstallScriptGenerator(const char* script, bool code, const char* component, bool exclude_from_all) - : cmInstallGenerator(0, std::vector<std::string>(), component, + : cmInstallGenerator(CM_NULLPTR, std::vector<std::string>(), component, MessageDefault, exclude_from_all) , Script(script) , Code(code) diff --git a/Source/cmInstallScriptGenerator.h b/Source/cmInstallScriptGenerator.h index ff2f2fa..dc00359 100644 --- a/Source/cmInstallScriptGenerator.h +++ b/Source/cmInstallScriptGenerator.h @@ -22,10 +22,10 @@ class cmInstallScriptGenerator : public cmInstallGenerator public: cmInstallScriptGenerator(const char* script, bool code, const char* component, bool exclude_from_all); - virtual ~cmInstallScriptGenerator(); + ~cmInstallScriptGenerator() CM_OVERRIDE; protected: - virtual void GenerateScript(std::ostream& os); + void GenerateScript(std::ostream& os) CM_OVERRIDE; std::string Script; bool Code; }; diff --git a/Source/cmInstallTargetGenerator.cxx b/Source/cmInstallTargetGenerator.cxx index d56bb05..448d278 100644 --- a/Source/cmInstallTargetGenerator.cxx +++ b/Source/cmInstallTargetGenerator.cxx @@ -30,7 +30,7 @@ cmInstallTargetGenerator::cmInstallTargetGenerator( : cmInstallGenerator(dest, configurations, component, message, exclude_from_all) , TargetName(targetName) - , Target(0) + , Target(CM_NULLPTR) , FilePermissions(file_permissions) , ImportLibrary(implib) , Optional(optional) @@ -294,8 +294,8 @@ void cmInstallTargetGenerator::GenerateScriptForConfig( &cmInstallTargetGenerator::PreReplacementTweaks); // Write code to install the target file. - const char* no_dir_permissions = 0; - const char* no_rename = 0; + const char* no_dir_permissions = CM_NULLPTR; + const char* no_rename = CM_NULLPTR; bool optional = this->Optional || this->ImportLibrary; this->AddInstallRule(os, this->GetDestination(config), type, filesFrom, optional, this->FilePermissions.c_str(), diff --git a/Source/cmInstallTargetGenerator.h b/Source/cmInstallTargetGenerator.h index 2fd85b5..b1c28b8 100644 --- a/Source/cmInstallTargetGenerator.h +++ b/Source/cmInstallTargetGenerator.h @@ -27,7 +27,7 @@ public: std::vector<std::string> const& configurations, const char* component, MessageLevel message, bool exclude_from_all, bool optional); - virtual ~cmInstallTargetGenerator(); + ~cmInstallTargetGenerator() CM_OVERRIDE; /** Select the policy for installing shared library linkable name symlinks. */ @@ -54,7 +54,7 @@ public: const std::string& config, NameType nameType = NameNormal); - void Compute(cmLocalGenerator* lg); + void Compute(cmLocalGenerator* lg) CM_OVERRIDE; cmGeneratorTarget* GetTarget() const { return this->Target; } @@ -63,10 +63,9 @@ public: std::string GetDestination(std::string const& config) const; protected: - virtual void GenerateScript(std::ostream& os); - virtual void GenerateScriptForConfig(std::ostream& os, - const std::string& config, - Indent const& indent); + void GenerateScript(std::ostream& os) CM_OVERRIDE; + void GenerateScriptForConfig(std::ostream& os, const std::string& config, + Indent const& indent) CM_OVERRIDE; typedef void (cmInstallTargetGenerator::*TweakMethod)(std::ostream&, Indent const&, const std::string&, diff --git a/Source/cmInstallTargetsCommand.h b/Source/cmInstallTargetsCommand.h index b0d04b0..b7d7f33 100644 --- a/Source/cmInstallTargetsCommand.h +++ b/Source/cmInstallTargetsCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmInstallTargetsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmInstallTargetsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "install_targets"; } + std::string GetName() const CM_OVERRIDE { return "install_targets"; } cmTypeMacro(cmInstallTargetsCommand, cmCommand); }; diff --git a/Source/cmInstalledFile.cxx b/Source/cmInstalledFile.cxx index ed0f74b..bfc5cf1 100644 --- a/Source/cmInstalledFile.cxx +++ b/Source/cmInstalledFile.cxx @@ -16,7 +16,7 @@ #include "cmSystemTools.h" cmInstalledFile::cmInstalledFile() - : NameExpression(0) + : NameExpression(CM_NULLPTR) { } diff --git a/Source/cmInstalledFile.h b/Source/cmInstalledFile.h index d000891..00ff611 100644 --- a/Source/cmInstalledFile.h +++ b/Source/cmInstalledFile.h @@ -22,7 +22,7 @@ class cmInstalledFile { public: - typedef cmsys::auto_ptr<cmCompiledGeneratorExpression> + typedef CM_AUTO_PTR<cmCompiledGeneratorExpression> CompiledGeneratorExpressionPtrType; typedef std::vector<cmCompiledGeneratorExpression*> ExpressionVectorType; diff --git a/Source/cmLinkDirectoriesCommand.h b/Source/cmLinkDirectoriesCommand.h index 7014a69..721d663 100644 --- a/Source/cmLinkDirectoriesCommand.h +++ b/Source/cmLinkDirectoriesCommand.h @@ -28,19 +28,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmLinkDirectoriesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmLinkDirectoriesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "link_directories"; } + std::string GetName() const CM_OVERRIDE { return "link_directories"; } cmTypeMacro(cmLinkDirectoriesCommand, cmCommand); diff --git a/Source/cmLinkItem.h b/Source/cmLinkItem.h index 0fbe093..8aa3981 100644 --- a/Source/cmLinkItem.h +++ b/Source/cmLinkItem.h @@ -26,7 +26,7 @@ class cmLinkItem : public std::string public: cmLinkItem() : std_string() - , Target(0) + , Target(CM_NULLPTR) { } cmLinkItem(const std_string& n, cmGeneratorTarget const* t) @@ -118,7 +118,7 @@ struct cmOptionalLinkInterface : public cmLinkInterface , AllDone(false) , Exists(false) , HadHeadSensitiveCondition(false) - , ExplicitLibraries(0) + , ExplicitLibraries(CM_NULLPTR) { } bool LibrariesDone; diff --git a/Source/cmLinkLibrariesCommand.h b/Source/cmLinkLibrariesCommand.h index 6ab50ce..45cc4d7 100644 --- a/Source/cmLinkLibrariesCommand.h +++ b/Source/cmLinkLibrariesCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmLinkLibrariesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmLinkLibrariesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "link_libraries"; } + std::string GetName() const CM_OVERRIDE { return "link_libraries"; } cmTypeMacro(cmLinkLibrariesCommand, cmCommand); }; diff --git a/Source/cmLinkedTree.h b/Source/cmLinkedTree.h index 1a85396..6b31074 100644 --- a/Source/cmLinkedTree.h +++ b/Source/cmLinkedTree.h @@ -56,7 +56,7 @@ public: public: iterator() - : Tree(0) + : Tree(CM_NULLPTR) , Position(0) { } diff --git a/Source/cmListCommand.h b/Source/cmListCommand.h index 56d9694..1c33c96 100644 --- a/Source/cmListCommand.h +++ b/Source/cmListCommand.h @@ -24,24 +24,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmListCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmListCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "list"; } + std::string GetName() const CM_OVERRIDE { return "list"; } cmTypeMacro(cmListCommand, cmCommand); diff --git a/Source/cmListFileCache.cxx b/Source/cmListFileCache.cxx index 4460418..28b3781 100644 --- a/Source/cmListFileCache.cxx +++ b/Source/cmListFileCache.cxx @@ -71,7 +71,7 @@ bool cmListFileParser::ParseFile() // Verify the Byte-Order-Mark, if any. if (bom != cmListFileLexer_BOM_None && bom != cmListFileLexer_BOM_UTF8) { - cmListFileLexer_SetFileName(this->Lexer, 0, 0); + cmListFileLexer_SetFileName(this->Lexer, CM_NULLPTR, CM_NULLPTR); this->IssueFileOpenError( "File starts with a Byte-Order-Mark that is not UTF-8."); return false; @@ -314,13 +314,13 @@ cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot bottom, Entry* cur) cmListFileBacktrace::cmListFileBacktrace() : Bottom() - , Cur(0) + , Cur(CM_NULLPTR) { } cmListFileBacktrace::cmListFileBacktrace(cmState::Snapshot snapshot) : Bottom(snapshot.GetCallStackBottom()) - , Cur(0) + , Cur(CM_NULLPTR) { } diff --git a/Source/cmLoadCacheCommand.h b/Source/cmLoadCacheCommand.h index 67d93ac..0755809 100644 --- a/Source/cmLoadCacheCommand.h +++ b/Source/cmLoadCacheCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmLoadCacheCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmLoadCacheCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "load_cache"; } + std::string GetName() const CM_OVERRIDE { return "load_cache"; } cmTypeMacro(cmLoadCacheCommand, cmCommand); diff --git a/Source/cmLoadCommandCommand.cxx b/Source/cmLoadCommandCommand.cxx index 081c22e..ddf6ce6 100644 --- a/Source/cmLoadCommandCommand.cxx +++ b/Source/cmLoadCommandCommand.cxx @@ -37,12 +37,12 @@ public: } ///! clean up any memory allocated by the plugin - ~cmLoadedCommand(); + ~cmLoadedCommand() CM_OVERRIDE; /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmLoadedCommand* newC = new cmLoadedCommand; // we must copy when we clone @@ -54,8 +54,8 @@ public: * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus&); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called at the end after all the information @@ -63,8 +63,8 @@ public: * not implement this method. At this point, reading and * writing to the cache can be done. */ - virtual void FinalPass(); - virtual bool HasFinalPass() const + void FinalPass() CM_OVERRIDE; + bool HasFinalPass() const CM_OVERRIDE { return this->info.FinalPass ? true : false; } @@ -72,7 +72,7 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return info.Name; } + std::string GetName() const CM_OVERRIDE { return info.Name; } static const char* LastName; static void TrapsForSignals(int sig) @@ -94,11 +94,11 @@ public: #endif signal(SIGILL, TrapsForSignalsCFunction); } else { - signal(SIGSEGV, 0); + signal(SIGSEGV, CM_NULLPTR); #ifdef SIGBUS - signal(SIGBUS, 0); + signal(SIGBUS, CM_NULLPTR); #endif - signal(SIGILL, 0); + signal(SIGILL, CM_NULLPTR); } } @@ -112,7 +112,7 @@ extern "C" void TrapsForSignalsCFunction(int sig) cmLoadedCommand::TrapsForSignals(sig); } -const char* cmLoadedCommand::LastName = 0; +const char* cmLoadedCommand::LastName = CM_NULLPTR; bool cmLoadedCommand::InitialPass(std::vector<std::string> const& args, cmExecutionStatus&) @@ -128,7 +128,7 @@ bool cmLoadedCommand::InitialPass(std::vector<std::string> const& args, // create argc and argv and then invoke the command int argc = static_cast<int>(args.size()); - char** argv = 0; + char** argv = CM_NULLPTR; if (argc) { argv = (char**)malloc(argc * sizeof(char*)); } diff --git a/Source/cmLoadCommandCommand.h b/Source/cmLoadCommandCommand.h index e00a01e..6552845 100644 --- a/Source/cmLoadCommandCommand.h +++ b/Source/cmLoadCommandCommand.h @@ -17,10 +17,10 @@ class cmLoadCommandCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmLoadCommandCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "load_command"; } + cmCommand* Clone() CM_OVERRIDE { return new cmLoadCommandCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "load_command"; } cmTypeMacro(cmLoadCommandCommand, cmCommand); }; diff --git a/Source/cmLocalCommonGenerator.h b/Source/cmLocalCommonGenerator.h index fd17ae3..0a8753d 100644 --- a/Source/cmLocalCommonGenerator.h +++ b/Source/cmLocalCommonGenerator.h @@ -24,7 +24,7 @@ class cmLocalCommonGenerator : public cmLocalGenerator public: cmLocalCommonGenerator(cmGlobalGenerator* gg, cmMakefile* mf, cmOutputConverter::RelativeRoot wd); - ~cmLocalCommonGenerator(); + ~cmLocalCommonGenerator() CM_OVERRIDE; std::string const& GetConfigName() { return this->ConfigName; } @@ -34,7 +34,7 @@ public: } std::string GetTargetFortranFlags(cmGeneratorTarget const* target, - std::string const& config); + std::string const& config) CM_OVERRIDE; protected: cmOutputConverter::RelativeRoot WorkingDirectory; diff --git a/Source/cmLocalGenerator.cxx b/Source/cmLocalGenerator.cxx index 0de9895..ff767e6 100644 --- a/Source/cmLocalGenerator.cxx +++ b/Source/cmLocalGenerator.cxx @@ -272,7 +272,7 @@ void cmLocalGenerator::GenerateInstallRules() // Choose a default install configuration. std::string default_config = config; const char* default_order[] = { "RELEASE", "MINSIZEREL", "RELWITHDEBINFO", - "DEBUG", 0 }; + "DEBUG", CM_NULLPTR }; for (const char** c = default_order; *c && default_config.empty(); ++c) { for (std::vector<std::string>::iterator i = configurationTypes.begin(); i != configurationTypes.end(); ++i) { @@ -445,7 +445,7 @@ cmGeneratorTarget* cmLocalGenerator::FindLocalNonAliasGeneratorTarget( if (ti != this->GeneratorTargets.end()) { return *ti; } - return 0; + return CM_NULLPTR; } void cmLocalGenerator::ComputeTargetManifest() @@ -508,7 +508,7 @@ static const char* ruleReplaceVars[] = { "CMAKE_RANLIB", "CMAKE_LINKER", "CMAKE_CL_SHOWINCLUDES_PREFIX", - 0 + CM_NULLPTR }; std::string cmLocalGenerator::ExpandRuleVariable( @@ -704,13 +704,13 @@ std::string cmLocalGenerator::ExpandRuleVariable( std::string actualReplace = ruleReplaceVars[pos]; // If this is the compiler then look for the extra variable // _COMPILER_ARG1 which must be the first argument to the compiler - const char* compilerArg1 = 0; - const char* compilerTarget = 0; - const char* compilerOptionTarget = 0; - const char* compilerExternalToolchain = 0; - const char* compilerOptionExternalToolchain = 0; - const char* compilerSysroot = 0; - const char* compilerOptionSysroot = 0; + const char* compilerArg1 = CM_NULLPTR; + const char* compilerTarget = CM_NULLPTR; + const char* compilerOptionTarget = CM_NULLPTR; + const char* compilerExternalToolchain = CM_NULLPTR; + const char* compilerOptionExternalToolchain = CM_NULLPTR; + const char* compilerSysroot = CM_NULLPTR; + const char* compilerOptionSysroot = CM_NULLPTR; if (actualReplace == "CMAKE_${LANG}_COMPILER") { std::string arg1 = actualReplace + "_ARG1"; cmSystemTools::ReplaceString(arg1, "${LANG}", lang); @@ -872,7 +872,7 @@ std::string cmLocalGenerator::GetIncludeFlags( // normal flag is repeated for each directory. std::string sysFlagVar = "CMAKE_INCLUDE_SYSTEM_FLAG_"; sysFlagVar += lang; - const char* sysIncludeFlag = 0; + const char* sysIncludeFlag = CM_NULLPTR; if (repeatFlag) { sysIncludeFlag = this->Makefile->GetDefinition(sysFlagVar); } @@ -1585,7 +1585,7 @@ void cmLocalGenerator::AddArchitectureFlags(std::string& flags, target->GetAppleArchs(config, archs); const char* sysroot = this->Makefile->GetDefinition("CMAKE_OSX_SYSROOT"); if (sysroot && sysroot[0] == '/' && !sysroot[1]) { - sysroot = 0; + sysroot = CM_NULLPTR; } std::string sysrootFlagVar = std::string("CMAKE_") + lang + "_SYSROOT_FLAG"; @@ -1925,7 +1925,7 @@ void cmLocalGenerator::AddVisibilityPresetFlags( } std::string warnCMP0063; - std::string* pWarnCMP0063 = 0; + std::string* pWarnCMP0063 = CM_NULLPTR; if (target->GetType() != cmState::SHARED_LIBRARY && target->GetType() != cmState::MODULE_LIBRARY && !target->IsExecutableWithExports()) { @@ -2036,7 +2036,7 @@ void cmLocalGenerator::AddPositionIndependentFlags(std::string& flags, std::string const& lang, int targetType) { - const char* picFlags = 0; + const char* picFlags = CM_NULLPTR; if (targetType == cmState::EXECUTABLE) { std::string flagsVar = "CMAKE_"; @@ -2217,7 +2217,7 @@ const char* cmLocalGenerator::GetFeature(const std::string& feature, } snp = snp.GetBuildsystemDirectoryParent(); } - return 0; + return CM_NULLPTR; } std::string cmLocalGenerator::GetProjectName() const @@ -2280,7 +2280,7 @@ void cmLocalGenerator::GenerateTargetInstallRules( // Include the user-specified pre-install script for this target. if (const char* preinstall = (*l)->GetProperty("PRE_INSTALL_SCRIPT")) { - cmInstallScriptGenerator g(preinstall, false, 0, false); + cmInstallScriptGenerator g(preinstall, false, CM_NULLPTR, false); g.Generate(os, config, configurationTypes); } @@ -2333,7 +2333,7 @@ void cmLocalGenerator::GenerateTargetInstallRules( // Include the user-specified post-install script for this target. if (const char* postinstall = (*l)->GetProperty("POST_INSTALL_SCRIPT")) { - cmInstallScriptGenerator g(postinstall, false, 0, false); + cmInstallScriptGenerator g(postinstall, false, CM_NULLPTR, false); g.Generate(os, config, configurationTypes); } } diff --git a/Source/cmLocalGenerator.h b/Source/cmLocalGenerator.h index 66fbe01..fa4bb30 100644 --- a/Source/cmLocalGenerator.h +++ b/Source/cmLocalGenerator.h @@ -300,9 +300,9 @@ public: std::string ConstructComment(cmCustomCommandGenerator const& ccg, const char* default_comment = ""); // Compute object file names. - std::string GetObjectFileNameWithoutTarget(const cmSourceFile& source, - std::string const& dir_max, - bool* hasSourceExtension = 0); + std::string GetObjectFileNameWithoutTarget( + const cmSourceFile& source, std::string const& dir_max, + bool* hasSourceExtension = CM_NULLPTR); /** Fill out the static linker flags for the given target. */ void GetStaticLibraryFlags(std::string& flags, std::string const& config, @@ -329,7 +329,7 @@ public: virtual void ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, - cmGeneratorTarget const* gt = 0); + cmGeneratorTarget const* gt = CM_NULLPTR); bool IsWindowsShell() const; bool IsWatcomWMake() const; diff --git a/Source/cmLocalNinjaGenerator.h b/Source/cmLocalNinjaGenerator.h index 9899360..6e61087 100644 --- a/Source/cmLocalNinjaGenerator.h +++ b/Source/cmLocalNinjaGenerator.h @@ -34,12 +34,12 @@ class cmLocalNinjaGenerator : public cmLocalCommonGenerator public: cmLocalNinjaGenerator(cmGlobalGenerator* gg, cmMakefile* mf); - virtual ~cmLocalNinjaGenerator(); + ~cmLocalNinjaGenerator() CM_OVERRIDE; - virtual void Generate(); + void Generate() CM_OVERRIDE; - virtual std::string GetTargetDirectory( - cmGeneratorTarget const* target) const; + std::string GetTargetDirectory(cmGeneratorTarget const* target) const + CM_OVERRIDE; const cmGlobalNinjaGenerator* GetGlobalNinjaGenerator() const; cmGlobalNinjaGenerator* GetGlobalNinjaGenerator(); @@ -72,19 +72,19 @@ public: void AppendCustomCommandDeps(cmCustomCommandGenerator const& ccg, cmNinjaDeps& ninjaDeps); - virtual std::string ConvertToLinkReference( - std::string const& lib, - cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL); + std::string ConvertToLinkReference(std::string const& lib, + cmOutputConverter::OutputFormat format = + cmOutputConverter::SHELL) CM_OVERRIDE; - virtual void ComputeObjectFilenames( + void ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, - cmGeneratorTarget const* gt = 0); + cmGeneratorTarget const* gt = CM_NULLPTR) CM_OVERRIDE; protected: - virtual std::string ConvertToIncludeReference( + std::string ConvertToIncludeReference( std::string const& path, cmOutputConverter::OutputFormat format = cmOutputConverter::SHELL, - bool forceFullPaths = false); + bool forceFullPaths = false) CM_OVERRIDE; private: cmGeneratedFileStream& GetBuildFileStream() const; diff --git a/Source/cmLocalUnixMakefileGenerator3.cxx b/Source/cmLocalUnixMakefileGenerator3.cxx index 0478a3a..75970772 100644 --- a/Source/cmLocalUnixMakefileGenerator3.cxx +++ b/Source/cmLocalUnixMakefileGenerator3.cxx @@ -30,8 +30,8 @@ #include "cmDependsJava.h" #endif +#include <cm_auto_ptr.hxx> #include <cmsys/Terminal.h> -#include <cmsys/auto_ptr.hxx> #include <algorithm> #include <queue> @@ -121,7 +121,7 @@ void cmLocalUnixMakefileGenerator3::Generate() if ((*t)->GetType() == cmState::INTERFACE_LIBRARY) { continue; } - cmsys::auto_ptr<cmMakefileTargetGenerator> tg( + CM_AUTO_PTR<cmMakefileTargetGenerator> tg( cmMakefileTargetGenerator::New(*t)); if (tg.get()) { tg->WriteRuleFiles(); @@ -340,8 +340,8 @@ void cmLocalUnixMakefileGenerator3::WriteObjectConvenienceRule( std::vector<std::string> depends; depends.push_back(output); std::vector<std::string> no_commands; - this->WriteMakeRule(ruleFileStream, 0, outNoExt, depends, no_commands, - true, true); + this->WriteMakeRule(ruleFileStream, CM_NULLPTR, outNoExt, depends, + no_commands, true, true); inHelp = false; } @@ -703,8 +703,8 @@ void cmLocalUnixMakefileGenerator3::WriteSpecialTargetsTop( // Add a fake suffix to keep HP happy. Must be max 32 chars for SGI make. std::vector<std::string> depends; depends.push_back(".hpux_make_needs_suffix_list"); - this->WriteMakeRule(makefileStream, 0, ".SUFFIXES", depends, no_commands, - false); + this->WriteMakeRule(makefileStream, CM_NULLPTR, ".SUFFIXES", depends, + no_commands, false); if (this->IsWatcomWMake()) { // Switch on WMake feature, if an error or interrupt occurs during // makefile processing, the current target being made may be deleted @@ -1164,7 +1164,7 @@ void cmLocalUnixMakefileGenerator3::AppendEcho( line = ""; // Progress appears only on first line. - progress = 0; + progress = CM_NULLPTR; // Terminate on end-of-string. if (*c == '\0') { @@ -1433,7 +1433,7 @@ bool cmLocalUnixMakefileGenerator3::ScanDependencies( std::string lang = *li; // Create the scanner for this language - cmDepends* scanner = 0; + cmDepends* scanner = CM_NULLPTR; if (lang == "C" || lang == "CXX" || lang == "RC" || lang == "ASM") { // TODO: Handle RC (resource files) dependencies correctly. scanner = new cmDependsC(this, targetDir, lang, &validDeps); diff --git a/Source/cmLocalUnixMakefileGenerator3.h b/Source/cmLocalUnixMakefileGenerator3.h index a65a1a1..42d1d91 100644 --- a/Source/cmLocalUnixMakefileGenerator3.h +++ b/Source/cmLocalUnixMakefileGenerator3.h @@ -33,14 +33,14 @@ class cmLocalUnixMakefileGenerator3 : public cmLocalCommonGenerator { public: cmLocalUnixMakefileGenerator3(cmGlobalGenerator* gg, cmMakefile* mf); - virtual ~cmLocalUnixMakefileGenerator3(); + ~cmLocalUnixMakefileGenerator3() CM_OVERRIDE; - virtual void ComputeHomeRelativeOutputPath(); + void ComputeHomeRelativeOutputPath() CM_OVERRIDE; /** * Generate the makefile for this directory. */ - virtual void Generate(); + void Generate() CM_OVERRIDE; // this returns the relative path between the HomeOutputDirectory and this // local generators StartOutputDirectory @@ -90,8 +90,9 @@ public: const std::string& tgt); // append flags to a string - virtual void AppendFlags(std::string& flags, const std::string& newFlags); - virtual void AppendFlags(std::string& flags, const char* newFlags); + void AppendFlags(std::string& flags, + const std::string& newFlags) CM_OVERRIDE; + void AppendFlags(std::string& flags, const char* newFlags) CM_OVERRIDE; // append an echo command enum EchoColor @@ -109,13 +110,14 @@ public: std::string Arg; }; void AppendEcho(std::vector<std::string>& commands, std::string const& text, - EchoColor color = EchoNormal, EchoProgress const* = 0); + EchoColor color = EchoNormal, + EchoProgress const* = CM_NULLPTR); /** Get whether the makefile is to have color. */ bool GetColorMakefile() const { return this->ColorMakefile; } - virtual std::string GetTargetDirectory( - cmGeneratorTarget const* target) const; + std::string GetTargetDirectory(cmGeneratorTarget const* target) const + CM_OVERRIDE; // create a command that cds to the start dir then runs the commands void CreateCDCommand(std::vector<std::string>& commands, @@ -130,11 +132,11 @@ public: /** Called from command-line hook to bring dependencies up to date for a target. */ - virtual bool UpdateDependencies(const char* tgtInfo, bool verbose, - bool color); + bool UpdateDependencies(const char* tgtInfo, bool verbose, + bool color) CM_OVERRIDE; /** Called from command-line hook to clear dependencies. */ - virtual void ClearDependencies(cmMakefile* mf, bool verbose); + void ClearDependencies(cmMakefile* mf, bool verbose) CM_OVERRIDE; /** write some extra rules such as make test etc */ void WriteSpecialTargetsTop(std::ostream& makefileStream); @@ -235,10 +237,11 @@ protected: std::vector<std::string>& commands, cmCustomCommandGenerator const& ccg, cmGeneratorTarget* target, bool echo_comment = false, cmOutputConverter::RelativeRoot relative = cmOutputConverter::HOME_OUTPUT, - std::ostream* content = 0); + std::ostream* content = CM_NULLPTR); void AppendCleanCommand(std::vector<std::string>& commands, const std::vector<std::string>& files, - cmGeneratorTarget* target, const char* filename = 0); + cmGeneratorTarget* target, + const char* filename = CM_NULLPTR); // Helper methods for dependeny updates. bool ScanDependencies( @@ -253,9 +256,9 @@ private: cmGeneratorTarget* target, cmOutputConverter::RelativeRoot relative); - virtual void ComputeObjectFilenames( + void ComputeObjectFilenames( std::map<cmSourceFile const*, std::string>& mapping, - cmGeneratorTarget const* gt = 0); + cmGeneratorTarget const* gt = CM_NULLPTR) CM_OVERRIDE; friend class cmMakefileTargetGenerator; friend class cmMakefileExecutableTargetGenerator; @@ -272,7 +275,7 @@ private: cmGeneratorTarget* Target; std::string Language; LocalObjectEntry() - : Target(0) + : Target(CM_NULLPTR) , Language() { } diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx index 2f6bf07..c38e99c 100644 --- a/Source/cmLocalVisualStudio7Generator.cxx +++ b/Source/cmLocalVisualStudio7Generator.cxx @@ -1850,7 +1850,7 @@ void cmLocalVisualStudio7Generator::OutputTargetRules( if (!addedPrelink) { event.Write(target->GetPreLinkCommands()); } - cmsys::auto_ptr<cmCustomCommand> pcc( + CM_AUTO_PTR<cmCustomCommand> pcc( this->MaybeCreateImplibDir(target, configName, this->FortranProject)); if (pcc.get()) { event.Write(*pcc); diff --git a/Source/cmLocalVisualStudioGenerator.cxx b/Source/cmLocalVisualStudioGenerator.cxx index 85ab615..bdb1c2b 100644 --- a/Source/cmLocalVisualStudioGenerator.cxx +++ b/Source/cmLocalVisualStudioGenerator.cxx @@ -74,12 +74,12 @@ void cmLocalVisualStudioGenerator::ComputeObjectFilenames( } } -cmsys::auto_ptr<cmCustomCommand> +CM_AUTO_PTR<cmCustomCommand> cmLocalVisualStudioGenerator::MaybeCreateImplibDir(cmGeneratorTarget* target, const std::string& config, bool isFortran) { - cmsys::auto_ptr<cmCustomCommand> pcc; + CM_AUTO_PTR<cmCustomCommand> pcc; // If an executable exports symbols then VS wants to create an // import library but forgets to create the output directory. diff --git a/Source/cmLocalVisualStudioGenerator.h b/Source/cmLocalVisualStudioGenerator.h index c24d813..87acda2 100644 --- a/Source/cmLocalVisualStudioGenerator.h +++ b/Source/cmLocalVisualStudioGenerator.h @@ -16,7 +16,7 @@ #include "cmGlobalVisualStudioGenerator.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> class cmSourceFile; class cmSourceGroup; @@ -59,8 +59,9 @@ protected: virtual bool CustomCommandUseLocal() const { return false; } /** Construct a custom command to make exe import lib dir. */ - cmsys::auto_ptr<cmCustomCommand> MaybeCreateImplibDir( - cmGeneratorTarget* target, const std::string& config, bool isFortran); + CM_AUTO_PTR<cmCustomCommand> MaybeCreateImplibDir(cmGeneratorTarget* target, + const std::string& config, + bool isFortran); }; #endif diff --git a/Source/cmLocale.h b/Source/cmLocale.h index e69c32e..f922c03 100644 --- a/Source/cmLocale.h +++ b/Source/cmLocale.h @@ -22,7 +22,7 @@ class cmLocaleRAII public: cmLocaleRAII() - : OldLocale(setlocale(LC_CTYPE, 0)) + : OldLocale(setlocale(LC_CTYPE, CM_NULLPTR)) { setlocale(LC_CTYPE, ""); } diff --git a/Source/cmMacroCommand.cxx b/Source/cmMacroCommand.cxx index 2caa401..ee9dc8a 100644 --- a/Source/cmMacroCommand.cxx +++ b/Source/cmMacroCommand.cxx @@ -21,7 +21,7 @@ public: cmMacroHelperCommand() {} ///! clean up any memory allocated by the macro - ~cmMacroHelperCommand() {} + ~cmMacroHelperCommand() CM_OVERRIDE {} /** * This is used to avoid including this command @@ -29,12 +29,12 @@ public: * cmMacroHelperCommand and cmFunctionHelperCommand * which cannot provide appropriate documentation. */ - virtual bool ShouldAppearInDocumentation() const { return false; } + bool ShouldAppearInDocumentation() const CM_OVERRIDE { return false; } /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() + cmCommand* Clone() CM_OVERRIDE { cmMacroHelperCommand* newC = new cmMacroHelperCommand; // we must copy when we clone @@ -48,16 +48,17 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&); + bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, + cmExecutionStatus&) CM_OVERRIDE; - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -65,7 +66,7 @@ public: /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return this->Args[0]; } + std::string GetName() const CM_OVERRIDE { return this->Args[0]; } cmTypeMacro(cmMacroHelperCommand, cmCommand); diff --git a/Source/cmMacroCommand.h b/Source/cmMacroCommand.h index 11d2e1c..541b54f 100644 --- a/Source/cmMacroCommand.h +++ b/Source/cmMacroCommand.h @@ -20,10 +20,10 @@ class cmMacroFunctionBlocker : public cmFunctionBlocker { public: cmMacroFunctionBlocker() { this->Depth = 0; } - virtual ~cmMacroFunctionBlocker() {} - virtual bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf, - cmExecutionStatus&); - virtual bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf); + ~cmMacroFunctionBlocker() CM_OVERRIDE {} + bool IsFunctionBlocked(const cmListFileFunction&, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; + bool ShouldRemove(const cmListFileFunction&, cmMakefile& mf) CM_OVERRIDE; std::vector<std::string> Args; std::vector<cmListFileFunction> Functions; @@ -37,24 +37,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmMacroCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmMacroCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "macro"; } + std::string GetName() const CM_OVERRIDE { return "macro"; } cmTypeMacro(cmMacroCommand, cmCommand); }; diff --git a/Source/cmMakeDirectoryCommand.h b/Source/cmMakeDirectoryCommand.h index 1a86398..de4ab8b 100644 --- a/Source/cmMakeDirectoryCommand.h +++ b/Source/cmMakeDirectoryCommand.h @@ -29,24 +29,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmMakeDirectoryCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmMakeDirectoryCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "make_directory"; } + std::string GetName() const CM_OVERRIDE { return "make_directory"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmMakeDirectoryCommand, cmCommand); }; diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx index e8c1576..0d550dd 100644 --- a/Source/cmMakefile.cxx +++ b/Source/cmMakefile.cxx @@ -35,10 +35,10 @@ #include "cmake.h" #include <stdlib.h> // required for atoi +#include <cm_auto_ptr.hxx> #include <cmsys/FStream.hxx> #include <cmsys/RegularExpression.hxx> #include <cmsys/SystemTools.hxx> -#include <cmsys/auto_ptr.hxx> #include <assert.h> #include <ctype.h> // for isspace @@ -262,7 +262,7 @@ bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff, // Lookup the command prototype. if (cmCommand* proto = this->GetState()->GetCommand(name)) { // Clone the prototype. - cmsys::auto_ptr<cmCommand> pcmd(proto->Clone()); + CM_AUTO_PTR<cmCommand> pcmd(proto->Clone()); pcmd->SetMakefile(this); // Decide whether to invoke the command. @@ -589,9 +589,8 @@ void cmMakefile::EnforceDirectoryLevelRules() const void cmMakefile::AddEvaluationFile( const std::string& inputFile, - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName, - cmsys::auto_ptr<cmCompiledGeneratorExpression> condition, - bool inputIsContent) + CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName, + CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, bool inputIsContent) { this->EvaluationFiles.push_back(new cmGeneratorExpressionEvaluationFile( inputFile, outputName, condition, inputIsContent)); @@ -787,7 +786,7 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput( // Make sure there is at least one output. if (outputs.empty()) { cmSystemTools::Error("Attempt to add a custom rule with no output!"); - return 0; + return CM_NULLPTR; } // Validate custom commands. TODO: More strict? @@ -798,12 +797,12 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput( std::ostringstream e; e << "COMMAND may not contain literal quotes:\n " << cl[0] << "\n"; this->IssueMessage(cmake::FATAL_ERROR, e.str()); - return 0; + return CM_NULLPTR; } } // Choose a source file on which to store the custom command. - cmSourceFile* file = 0; + cmSourceFile* file = CM_NULLPTR; if (!commandLines.empty() && !main_dependency.empty()) { // The main dependency was specified. Use it unless a different // custom command already used it. @@ -817,7 +816,7 @@ cmSourceFile* cmMakefile::AddCustomCommandToOutput( } else { // The existing custom command is different. We need to // generate a rule file for this new command. - file = 0; + file = CM_NULLPTR; } } else if (!file) { file = this->CreateSource(main_dependency); @@ -938,7 +937,7 @@ void cmMakefile::AddCustomCommandOldStyle( std::vector<std::string> no_byproducts; this->AddCustomCommandToTarget(target, no_byproducts, depends, commandLines, cmTarget::POST_BUILD, comment, - 0); + CM_NULLPTR); return; } @@ -956,14 +955,14 @@ void cmMakefile::AddCustomCommandOldStyle( if (sourceFiles.find(source)) { // The source looks like a real file. Use it as the main dependency. sf = this->AddCustomCommandToOutput(output, depends, source, - commandLines, comment, 0); + commandLines, comment, CM_NULLPTR); } else { // The source may not be a real file. Do not use a main dependency. std::string no_main_dependency = ""; std::vector<std::string> depends2 = depends; depends2.push_back(source); sf = this->AddCustomCommandToOutput(output, depends2, no_main_dependency, - commandLines, comment, 0); + commandLines, comment, CM_NULLPTR); } // If the rule was added to the source (and not a .rule file), @@ -1817,8 +1816,8 @@ void cmMakefile::RemoveDefinition(const std::string& name) #ifdef CMAKE_BUILD_WITH_CMAKE cmVariableWatch* vv = this->GetVariableWatch(); if (vv) { - vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS, 0, - this); + vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS, + CM_NULLPTR, this); } #endif } @@ -1951,7 +1950,7 @@ cmSourceFile* cmMakefile::LinearGetSourceFileWithOutput( } // otherwise return NULL - return 0; + return CM_NULLPTR; } cmSourceFile* cmMakefile::GetSourceFileWithOutput( @@ -1967,14 +1966,14 @@ cmSourceFile* cmMakefile::GetSourceFileWithOutput( if (o != this->OutputToSource.end()) { return (*o).second; } - return 0; + return CM_NULLPTR; } #if defined(CMAKE_BUILD_WITH_CMAKE) cmSourceGroup* cmMakefile::GetSourceGroup( const std::vector<std::string>& name) const { - cmSourceGroup* sg = 0; + cmSourceGroup* sg = CM_NULLPTR; // first look for source group starting with the same as the one we want for (std::vector<cmSourceGroup>::const_iterator sgIt = @@ -1987,11 +1986,11 @@ cmSourceGroup* cmMakefile::GetSourceGroup( } } - if (sg != 0) { + if (sg != CM_NULLPTR) { // iterate through its children to find match source group for (unsigned int i = 1; i < name.size(); ++i) { sg = sg->LookupChild(name[i].c_str()); - if (sg == 0) { + if (sg == CM_NULLPTR) { break; } } @@ -2009,14 +2008,14 @@ void cmMakefile::AddSourceGroup(const std::string& name, const char* regex) void cmMakefile::AddSourceGroup(const std::vector<std::string>& name, const char* regex) { - cmSourceGroup* sg = 0; + cmSourceGroup* sg = CM_NULLPTR; std::vector<std::string> currentName; int i = 0; const int lastElement = static_cast<int>(name.size() - 1); for (i = lastElement; i >= 0; --i) { currentName.assign(name.begin(), name.begin() + i + 1); sg = this->GetSourceGroup(currentName); - if (sg != 0) { + if (sg != CM_NULLPTR) { break; } } @@ -2043,7 +2042,8 @@ void cmMakefile::AddSourceGroup(const std::vector<std::string>& name, } // build the whole source group path for (++i; i <= lastElement; ++i) { - sg->AddChild(cmSourceGroup(name[i].c_str(), 0, sg->GetFullName())); + sg->AddChild( + cmSourceGroup(name[i].c_str(), CM_NULLPTR, sg->GetFullName())); sg = sg->LookupChild(name[i].c_str()); } @@ -2263,7 +2263,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const } } #endif - return def != NULL; + return def != CM_NULLPTR; } const char* cmMakefile::GetDefinition(const std::string& name) const @@ -2570,7 +2570,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew( openstack.pop_back(); result.append(last, in - last); std::string const& lookup = result.substr(var.loc); - const char* value = NULL; + const char* value = CM_NULLPTR; std::string varresult; static const std::string lineVar = "CMAKE_CURRENT_LIST_LINE"; switch (var.domain) { @@ -2623,7 +2623,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew( if (!atOnly) { t_lookup lookup; const char* next = in + 1; - const char* start = NULL; + const char* start = CM_NULLPTR; char nextc = *next; if (nextc == '{') { // Looking for a variable. @@ -2889,7 +2889,7 @@ void cmMakefile::PopFunctionBlockerBarrier(bool reportError) FunctionBlockersType::size_type barrier = this->FunctionBlockerBarriers.back(); while (this->FunctionBlockers.size() > barrier) { - cmsys::auto_ptr<cmFunctionBlocker> fb(this->FunctionBlockers.back()); + CM_AUTO_PTR<cmFunctionBlocker> fb(this->FunctionBlockers.back()); this->FunctionBlockers.pop_back(); if (reportError) { // Report the context in which the unclosed block was opened. @@ -3026,7 +3026,7 @@ void cmMakefile::AddFunctionBlocker(cmFunctionBlocker* fb) this->FunctionBlockers.push_back(fb); } -cmsys::auto_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker( +CM_AUTO_PTR<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker( cmFunctionBlocker* fb, const cmListFileFunction& lff) { // Find the function blocker stack barrier for the current scope. @@ -3059,11 +3059,11 @@ cmsys::auto_ptr<cmFunctionBlocker> cmMakefile::RemoveFunctionBlocker( } cmFunctionBlocker* b = *pos; this->FunctionBlockers.erase(pos); - return cmsys::auto_ptr<cmFunctionBlocker>(b); + return CM_AUTO_PTR<cmFunctionBlocker>(b); } } - return cmsys::auto_ptr<cmFunctionBlocker>(); + return CM_AUTO_PTR<cmFunctionBlocker>(); } const char* cmMakefile::GetHomeDirectory() const @@ -3107,7 +3107,7 @@ cmSourceFile* cmMakefile::GetSource(const std::string& sourceName) const return sf; } } - return 0; + return CM_NULLPTR; } cmSourceFile* cmMakefile::CreateSource(const std::string& sourceName, @@ -3277,7 +3277,7 @@ cmVariableWatch* cmMakefile::GetVariableWatch() const this->GetCMakeInstance()->GetVariableWatch()) { return this->GetCMakeInstance()->GetVariableWatch(); } - return 0; + return CM_NULLPTR; } #endif @@ -3438,8 +3438,8 @@ void cmMakefile::ConfigureString(const std::string& input, std::string& output, } // Perform variable replacements. - this->ExpandVariablesInString(output, escapeQuotes, true, atOnly, 0, -1, - true, true); + this->ExpandVariablesInString(output, escapeQuotes, true, atOnly, CM_NULLPTR, + -1, true, true); } int cmMakefile::ConfigureFile(const char* infile, const char* outfile, @@ -3578,7 +3578,7 @@ cmTarget* cmMakefile::FindLocalNonAliasTarget(const std::string& name) const if (i != this->Targets.end()) { return &i->second; } - return 0; + return CM_NULLPTR; } cmTest* cmMakefile::CreateTest(const std::string& testName) @@ -3600,7 +3600,7 @@ cmTest* cmMakefile::GetTest(const std::string& testName) const if (mi != this->Tests.end()) { return mi->second; } - return 0; + return CM_NULLPTR; } void cmMakefile::AddCMakeDependFilesFromUser() @@ -3691,7 +3691,7 @@ cmTarget* cmMakefile::AddImportedTarget(const std::string& name, cmState::TargetType type, bool global) { // Create the target. - cmsys::auto_ptr<cmTarget> target(new cmTarget); + CM_AUTO_PTR<cmTarget> target(new cmTarget); target->SetType(type, name); target->MarkAsImported(global); target->SetMakefile(this); @@ -4061,10 +4061,10 @@ bool cmMakefile::IgnoreErrorsCMP0061() const } #define FEATURE_STRING(F) , #F -static const char* const C_FEATURES[] = { 0 FOR_EACH_C_FEATURE( +static const char* const C_FEATURES[] = { CM_NULLPTR FOR_EACH_C_FEATURE( FEATURE_STRING) }; -static const char* const CXX_FEATURES[] = { 0 FOR_EACH_CXX_FEATURE( +static const char* const CXX_FEATURES[] = { CM_NULLPTR FOR_EACH_CXX_FEATURE( FEATURE_STRING) }; #undef FEATURE_STRING @@ -4178,7 +4178,7 @@ const char* cmMakefile::CompileFeaturesAvailable(const std::string& lang, this->GetCMakeInstance()->IssueMessage(cmake::FATAL_ERROR, e.str(), this->Backtrace); } - return 0; + return CM_NULLPTR; } return featuresKnown; } diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h index 1680c6a..d07b4e1 100644 --- a/Source/cmMakefile.h +++ b/Source/cmMakefile.h @@ -28,10 +28,10 @@ #include "cmSourceGroup.h" #endif +#include <cm_auto_ptr.hxx> #include <cmsys/RegularExpression.hxx> -#include <cmsys/auto_ptr.hxx> #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP #include <unordered_map> #else #include <cmsys/hash_map.hxx> @@ -97,7 +97,7 @@ public: * Remove the function blocker whose scope ends with the given command. * This returns ownership of the function blocker object. */ - cmsys::auto_ptr<cmFunctionBlocker> RemoveFunctionBlocker( + CM_AUTO_PTR<cmFunctionBlocker> RemoveFunctionBlocker( cmFunctionBlocker* fb, const cmListFileFunction& lff); /** @@ -182,24 +182,23 @@ public: * Add a utility to the build. A utiltity target is a command that * is run every time the target is built. */ - cmTarget* AddUtilityCommand(const std::string& utilityName, - bool excludeFromAll, - const std::vector<std::string>& depends, - const char* workingDirectory, - const char* command, const char* arg1 = 0, - const char* arg2 = 0, const char* arg3 = 0, - const char* arg4 = 0); + cmTarget* AddUtilityCommand( + const std::string& utilityName, bool excludeFromAll, + const std::vector<std::string>& depends, const char* workingDirectory, + const char* command, const char* arg1 = CM_NULLPTR, + const char* arg2 = CM_NULLPTR, const char* arg3 = CM_NULLPTR, + const char* arg4 = CM_NULLPTR); cmTarget* AddUtilityCommand( const std::string& utilityName, bool excludeFromAll, const char* workingDirectory, const std::vector<std::string>& depends, const cmCustomCommandLines& commandLines, bool escapeOldStyle = true, - const char* comment = 0, bool uses_terminal = false); + const char* comment = CM_NULLPTR, bool uses_terminal = false); cmTarget* AddUtilityCommand( const std::string& utilityName, bool excludeFromAll, const char* workingDirectory, const std::vector<std::string>& byproducts, const std::vector<std::string>& depends, const cmCustomCommandLines& commandLines, bool escapeOldStyle = true, - const char* comment = 0, bool uses_terminal = false); + const char* comment = CM_NULLPTR, bool uses_terminal = false); /** * Add a link library to the build. @@ -274,14 +273,14 @@ public: /** * Add a root source group for consideration when adding a new source. */ - void AddSourceGroup(const std::string& name, const char* regex = 0); + void AddSourceGroup(const std::string& name, const char* regex = CM_NULLPTR); /** * Add a source group for consideration when adding a new source. * name is tokenized. */ void AddSourceGroup(const std::vector<std::string>& name, - const char* regex = 0); + const char* regex = CM_NULLPTR); #endif @@ -519,8 +518,8 @@ public: const char* ExpandVariablesInString(std::string& source) const; const char* ExpandVariablesInString(std::string& source, bool escapeQuotes, bool noEscapes, bool atOnly = false, - const char* filename = 0, long line = -1, - bool removeEmpty = false, + const char* filename = CM_NULLPTR, + long line = -1, bool removeEmpty = false, bool replaceAt = false) const; /** @@ -592,11 +591,11 @@ public: */ bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs, std::vector<std::string>& outArgs, - const char* filename = 0) const; + const char* filename = CM_NULLPTR) const; bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs, std::vector<cmExpandedCommandArgument>& outArgs, - const char* filename = 0) const; + const char* filename = CM_NULLPTR) const; /** * Get the instance @@ -743,7 +742,7 @@ public: bool PolicyOptionalWarningEnabled(std::string const& var); bool AddRequiredTargetFeature(cmTarget* target, const std::string& feature, - std::string* error = 0) const; + std::string* error = CM_NULLPTR) const; bool CompileFeatureKnown(cmTarget const* target, const std::string& feature, std::string& lang, std::string* error) const; @@ -772,11 +771,10 @@ public: void EnforceDirectoryLevelRules() const; - void AddEvaluationFile( - const std::string& inputFile, - cmsys::auto_ptr<cmCompiledGeneratorExpression> outputName, - cmsys::auto_ptr<cmCompiledGeneratorExpression> condition, - bool inputIsContent); + void AddEvaluationFile(const std::string& inputFile, + CM_AUTO_PTR<cmCompiledGeneratorExpression> outputName, + CM_AUTO_PTR<cmCompiledGeneratorExpression> condition, + bool inputIsContent); std::vector<cmGeneratorExpressionEvaluationFile*> GetEvaluationFiles() const; std::vector<cmExportBuildFileGenerator*> GetExportBuildFileGenerators() @@ -796,7 +794,7 @@ protected: // libraries, classes, and executables mutable cmTargets Targets; #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, cmTarget*> TargetMap; #else typedef cmsys::hash_map<std::string, cmTarget*> TargetMap; @@ -915,7 +913,7 @@ private: // A map for fast output to input look up. #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, cmSourceFile*> OutputToSourceMap; #else typedef cmsys::hash_map<std::string, cmSourceFile*> OutputToSourceMap; @@ -933,11 +931,11 @@ private: std::vector<cmSourceFile*> QtUiFilesWithOptions; bool AddRequiredTargetCFeature(cmTarget* target, const std::string& feature, - std::string* error = 0) const; + std::string* error = CM_NULLPTR) const; bool AddRequiredTargetCxxFeature(cmTarget* target, const std::string& feature, - std::string* error = 0) const; + std::string* error = CM_NULLPTR) const; void CheckNeededCLanguage(const std::string& feature, bool& needC90, bool& needC99, bool& needC11) const; diff --git a/Source/cmMakefileExecutableTargetGenerator.cxx b/Source/cmMakefileExecutableTargetGenerator.cxx index ba4c6e6..9a37a33 100644 --- a/Source/cmMakefileExecutableTargetGenerator.cxx +++ b/Source/cmMakefileExecutableTargetGenerator.cxx @@ -418,8 +418,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) } // Write the build rule. - this->LocalGenerator->WriteMakeRule( - *this->BuildFileStream, 0, targetFullPathReal, depends, commands, false); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + targetFullPathReal, depends, commands, + false); // The symlink name for the target should depend on the real target // so if the target version changes it rebuilds and recreates the @@ -428,8 +429,9 @@ void cmMakefileExecutableTargetGenerator::WriteExecutableRule(bool relink) depends.clear(); commands.clear(); depends.push_back(targetFullPathReal); - this->LocalGenerator->WriteMakeRule( - *this->BuildFileStream, 0, targetFullPath, depends, commands, false); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + targetFullPath, depends, commands, + false); } // Write the main driver rule to build everything in this target. diff --git a/Source/cmMakefileExecutableTargetGenerator.h b/Source/cmMakefileExecutableTargetGenerator.h index 64cb17f..39def27 100644 --- a/Source/cmMakefileExecutableTargetGenerator.h +++ b/Source/cmMakefileExecutableTargetGenerator.h @@ -18,11 +18,11 @@ class cmMakefileExecutableTargetGenerator : public cmMakefileTargetGenerator { public: cmMakefileExecutableTargetGenerator(cmGeneratorTarget* target); - virtual ~cmMakefileExecutableTargetGenerator(); + ~cmMakefileExecutableTargetGenerator() CM_OVERRIDE; /* the main entry point for this class. Writes the Makefiles associated with this target */ - virtual void WriteRuleFiles(); + void WriteRuleFiles() CM_OVERRIDE; protected: virtual void WriteExecutableRule(bool relink); diff --git a/Source/cmMakefileLibraryTargetGenerator.cxx b/Source/cmMakefileLibraryTargetGenerator.cxx index 5348b80..380fd7d 100644 --- a/Source/cmMakefileLibraryTargetGenerator.cxx +++ b/Source/cmMakefileLibraryTargetGenerator.cxx @@ -111,7 +111,7 @@ void cmMakefileLibraryTargetGenerator::WriteObjectLibraryRules() this->AppendObjectDepends(depends); // Write the rule. - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, this->GeneratorTarget->GetName(), depends, commands, true); @@ -346,7 +346,7 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( commands, buildEcho, cmLocalUnixMakefileGenerator3::EchoLink, &progress); } - const char* forbiddenFlagVar = 0; + const char* forbiddenFlagVar = CM_NULLPTR; switch (this->GeneratorTarget->GetType()) { case cmState::SHARED_LIBRARY: forbiddenFlagVar = "_CREATE_SHARED_LIBRARY_FORBIDDEN_FLAGS"; @@ -762,8 +762,8 @@ void cmMakefileLibraryTargetGenerator::WriteLibraryRules( } // Write the build rule. - this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands, - false); + this->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, outputs, depends, + commands, false); // Write the main driver rule to build everything in this target. this->WriteTargetDriverRule(targetFullPath, relink); diff --git a/Source/cmMakefileLibraryTargetGenerator.h b/Source/cmMakefileLibraryTargetGenerator.h index f72dbd7..935d8b1 100644 --- a/Source/cmMakefileLibraryTargetGenerator.h +++ b/Source/cmMakefileLibraryTargetGenerator.h @@ -18,11 +18,11 @@ class cmMakefileLibraryTargetGenerator : public cmMakefileTargetGenerator { public: cmMakefileLibraryTargetGenerator(cmGeneratorTarget* target); - virtual ~cmMakefileLibraryTargetGenerator(); + ~cmMakefileLibraryTargetGenerator() CM_OVERRIDE; /* the main entry point for this class. Writes the Makefiles associated with this target */ - virtual void WriteRuleFiles(); + void WriteRuleFiles() CM_OVERRIDE; protected: void WriteObjectLibraryRules(); diff --git a/Source/cmMakefileTargetGenerator.cxx b/Source/cmMakefileTargetGenerator.cxx index 8b341a1..2f9c4da 100644 --- a/Source/cmMakefileTargetGenerator.cxx +++ b/Source/cmMakefileTargetGenerator.cxx @@ -33,12 +33,12 @@ cmMakefileTargetGenerator::cmMakefileTargetGenerator(cmGeneratorTarget* target) : cmCommonTargetGenerator(target) - , OSXBundleGenerator(0) - , MacOSXContentGenerator(0) + , OSXBundleGenerator(CM_NULLPTR) + , MacOSXContentGenerator(CM_NULLPTR) { - this->BuildFileStream = 0; - this->InfoFileStream = 0; - this->FlagFileStream = 0; + this->BuildFileStream = CM_NULLPTR; + this->InfoFileStream = CM_NULLPTR; + this->FlagFileStream = CM_NULLPTR; this->CustomCommandDriver = OnBuild; this->LocalGenerator = static_cast<cmLocalUnixMakefileGenerator3*>(target->GetLocalGenerator()); @@ -61,7 +61,7 @@ cmMakefileTargetGenerator::~cmMakefileTargetGenerator() cmMakefileTargetGenerator* cmMakefileTargetGenerator::New( cmGeneratorTarget* tgt) { - cmMakefileTargetGenerator* result = 0; + cmMakefileTargetGenerator* result = CM_NULLPTR; switch (tgt->GetType()) { case cmState::EXECUTABLE: @@ -134,12 +134,12 @@ void cmMakefileTargetGenerator::WriteTargetBuildRules() if (const char* additional_clean_files = this->Makefile->GetProperty("ADDITIONAL_MAKE_CLEAN_FILES")) { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(additional_clean_files); cmSystemTools::ExpandListArgument( cge->Evaluate(this->LocalGenerator, config, false, this->GeneratorTarget, - 0, 0), + CM_NULLPTR, CM_NULLPTR), this->CleanFiles); } @@ -320,7 +320,8 @@ void cmMakefileTargetGenerator::MacOSXContentGeneratorType::operator()( cmOutputConverter::SHELL); commands.push_back(copyCommand); this->Generator->LocalGenerator->WriteMakeRule( - *this->Generator->BuildFileStream, 0, output, depends, commands, false); + *this->Generator->BuildFileStream, CM_NULLPTR, output, depends, commands, + false); this->Generator->ExtraFiles.insert(output); } @@ -652,7 +653,8 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile( } // Write the rule. - this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands); + this->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, outputs, depends, + commands); bool do_preprocess_rules = lang_has_preprocessor && this->LocalGenerator->GetCreatePreprocessedSourceRules(); @@ -708,7 +710,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile( commands.push_back(cmd); } - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, relativeObjI, force_depends, commands, false); } @@ -754,7 +756,7 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile( commands.push_back(cmd); } - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, relativeObjS, force_depends, commands, false); } @@ -766,8 +768,9 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile( objectRequires += ".requires"; std::vector<std::string> p_depends; // always provide an empty requires target - this->LocalGenerator->WriteMakeRule( - *this->BuildFileStream, 0, objectRequires, p_depends, no_commands, true); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + objectRequires, p_depends, no_commands, + true); // write a build rule to recursively build what this obj provides std::string objectProvides = relativeObj; @@ -783,13 +786,14 @@ void cmMakefileTargetGenerator::WriteObjectBuildFile( p_depends.clear(); p_depends.push_back(objectRequires); - this->LocalGenerator->WriteMakeRule( - *this->BuildFileStream, 0, objectProvides, p_depends, r_commands, true); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + objectProvides, p_depends, r_commands, + true); // write the provides.build rule dependency on the obj file p_depends.clear(); p_depends.push_back(relativeObj); - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, temp, + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, temp, p_depends, no_commands, false); } @@ -815,8 +819,8 @@ void cmMakefileTargetGenerator::WriteTargetRequiresRules() } // Write the rule. - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, depTarget, - depends, no_commands, true); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + depTarget, depends, no_commands, true); } void cmMakefileTargetGenerator::WriteTargetCleanRules() @@ -837,8 +841,8 @@ void cmMakefileTargetGenerator::WriteTargetCleanRules() cmOutputConverter::HOME_OUTPUT); // Write the rule. - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, cleanTarget, - depends, commands, true); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + cleanTarget, depends, commands, true); } bool cmMakefileTargetGenerator::WriteMakeRule( @@ -892,7 +896,7 @@ bool cmMakefileTargetGenerator::WriteMakeRule( if (!o_symbolic) { output_commands.push_back("@$(CMAKE_COMMAND) -E touch_nocreate " + out); } - this->LocalGenerator->WriteMakeRule(os, 0, *o, output_depends, + this->LocalGenerator->WriteMakeRule(os, CM_NULLPTR, *o, output_depends, output_commands, o_symbolic, in_help); if (!o_symbolic) { @@ -1025,8 +1029,8 @@ void cmMakefileTargetGenerator::WriteTargetDependRules() } // Write the rule. - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, depTarget, - depends, commands, true); + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + depTarget, depends, commands, true); } void cmMakefileTargetGenerator::DriveCustomCommands( @@ -1088,8 +1092,8 @@ void cmMakefileTargetGenerator::GenerateCustomRuleFile( // Write the rule. const std::vector<std::string>& outputs = ccg.GetOutputs(); - bool symbolic = - this->WriteMakeRule(*this->BuildFileStream, 0, outputs, depends, commands); + bool symbolic = this->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, + outputs, depends, commands); // If the rule has changed make sure the output is rebuilt. if (!symbolic) { @@ -1254,7 +1258,7 @@ void cmMakefileTargetGenerator::WriteTargetDriverRule( std::vector<std::string> depends; depends.push_back(main_output); - const char* comment = 0; + const char* comment = CM_NULLPTR; if (relink) { // Setup the comment for the preinstall driver. comment = "Rule to relink during preinstall."; diff --git a/Source/cmMakefileTargetGenerator.h b/Source/cmMakefileTargetGenerator.h index c513026..7749d8b 100644 --- a/Source/cmMakefileTargetGenerator.h +++ b/Source/cmMakefileTargetGenerator.h @@ -35,7 +35,7 @@ class cmMakefileTargetGenerator : public cmCommonTargetGenerator public: // constructor to set the ivars cmMakefileTargetGenerator(cmGeneratorTarget* target); - virtual ~cmMakefileTargetGenerator(); + ~cmMakefileTargetGenerator() CM_OVERRIDE; // construct using this factory call static cmMakefileTargetGenerator* New(cmGeneratorTarget* tgt); @@ -83,7 +83,8 @@ protected: { } - void operator()(cmSourceFile const& source, const char* pkgloc); + void operator()(cmSourceFile const& source, + const char* pkgloc) CM_OVERRIDE; private: cmMakefileTargetGenerator* Generator; @@ -161,7 +162,8 @@ protected: std::vector<std::string>& makefile_depends, bool useWatcomQuote); - void AddIncludeFlags(std::string& flags, const std::string& lang); + void AddIncludeFlags(std::string& flags, + const std::string& lang) CM_OVERRIDE; virtual void CloseFileStreams(); void RemoveForbiddenFlags(const char* flagVar, const std::string& linkLang, diff --git a/Source/cmMakefileUtilityTargetGenerator.cxx b/Source/cmMakefileUtilityTargetGenerator.cxx index 6e44e8f..27006ee 100644 --- a/Source/cmMakefileUtilityTargetGenerator.cxx +++ b/Source/cmMakefileUtilityTargetGenerator.cxx @@ -95,7 +95,7 @@ void cmMakefileUtilityTargetGenerator::WriteRuleFiles() } // Write the rule. - this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, 0, + this->LocalGenerator->WriteMakeRule(*this->BuildFileStream, CM_NULLPTR, this->GeneratorTarget->GetName(), depends, commands, true); diff --git a/Source/cmMakefileUtilityTargetGenerator.h b/Source/cmMakefileUtilityTargetGenerator.h index dbb312c..b41fb8b 100644 --- a/Source/cmMakefileUtilityTargetGenerator.h +++ b/Source/cmMakefileUtilityTargetGenerator.h @@ -18,11 +18,11 @@ class cmMakefileUtilityTargetGenerator : public cmMakefileTargetGenerator { public: cmMakefileUtilityTargetGenerator(cmGeneratorTarget* target); - virtual ~cmMakefileUtilityTargetGenerator(); + ~cmMakefileUtilityTargetGenerator() CM_OVERRIDE; /* the main entry point for this class. Writes the Makefiles associated with this target */ - virtual void WriteRuleFiles(); + void WriteRuleFiles() CM_OVERRIDE; protected: }; diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx index 07f1fa8..2fb6a75 100644 --- a/Source/cmMarkAsAdvancedCommand.cxx +++ b/Source/cmMarkAsAdvancedCommand.cxx @@ -35,7 +35,7 @@ bool cmMarkAsAdvancedCommand::InitialPass(std::vector<std::string> const& args, cmState* state = this->Makefile->GetState(); if (!state->GetCacheEntryValue(variable)) { this->Makefile->GetCMakeInstance()->AddCacheEntry( - variable, 0, 0, cmState::UNINITIALIZED); + variable, CM_NULLPTR, CM_NULLPTR, cmState::UNINITIALIZED); overwrite = true; } if (!state->GetCacheEntryValue(variable)) { diff --git a/Source/cmMarkAsAdvancedCommand.h b/Source/cmMarkAsAdvancedCommand.h index add43c9..bb1b83c 100644 --- a/Source/cmMarkAsAdvancedCommand.h +++ b/Source/cmMarkAsAdvancedCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmMarkAsAdvancedCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmMarkAsAdvancedCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "mark_as_advanced"; } + std::string GetName() const CM_OVERRIDE { return "mark_as_advanced"; } /** * This determines if the command is invoked when in script mode. @@ -45,7 +45,7 @@ public: * make many of the modules usable in cmake/ctest scripts, (among them * FindUnixMake.cmake used by the CTEST_BUILD command. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmMarkAsAdvancedCommand, cmCommand); }; diff --git a/Source/cmMathCommand.h b/Source/cmMathCommand.h index 3ac6f41..b99e790 100644 --- a/Source/cmMathCommand.h +++ b/Source/cmMathCommand.h @@ -21,24 +21,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmMathCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmMathCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "math"; } + std::string GetName() const CM_OVERRIDE { return "math"; } cmTypeMacro(cmMathCommand, cmCommand); diff --git a/Source/cmMessageCommand.h b/Source/cmMessageCommand.h index afc5509..61767a1 100644 --- a/Source/cmMessageCommand.h +++ b/Source/cmMessageCommand.h @@ -24,24 +24,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmMessageCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmMessageCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "message"; } + std::string GetName() const CM_OVERRIDE { return "message"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmMessageCommand, cmCommand); }; diff --git a/Source/cmNinjaNormalTargetGenerator.cxx b/Source/cmNinjaNormalTargetGenerator.cxx index 04ba842..77d3901 100644 --- a/Source/cmNinjaNormalTargetGenerator.cxx +++ b/Source/cmNinjaNormalTargetGenerator.cxx @@ -134,7 +134,7 @@ const char* cmNinjaNormalTargetGenerator::GetVisibleTypeName() const case cmState::EXECUTABLE: return "executable"; default: - return 0; + return CM_NULLPTR; } } diff --git a/Source/cmNinjaNormalTargetGenerator.h b/Source/cmNinjaNormalTargetGenerator.h index 300618c..f466e17 100644 --- a/Source/cmNinjaNormalTargetGenerator.h +++ b/Source/cmNinjaNormalTargetGenerator.h @@ -27,9 +27,9 @@ class cmNinjaNormalTargetGenerator : public cmNinjaTargetGenerator { public: cmNinjaNormalTargetGenerator(cmGeneratorTarget* target); - ~cmNinjaNormalTargetGenerator(); + ~cmNinjaNormalTargetGenerator() CM_OVERRIDE; - void Generate(); + void Generate() CM_OVERRIDE; private: std::string LanguageLinkerRule() const; diff --git a/Source/cmNinjaTargetGenerator.cxx b/Source/cmNinjaTargetGenerator.cxx index b413c33..1d3e608 100644 --- a/Source/cmNinjaTargetGenerator.cxx +++ b/Source/cmNinjaTargetGenerator.cxx @@ -53,14 +53,14 @@ cmNinjaTargetGenerator* cmNinjaTargetGenerator::New(cmGeneratorTarget* target) } default: - return 0; + return CM_NULLPTR; } } cmNinjaTargetGenerator::cmNinjaTargetGenerator(cmGeneratorTarget* target) : cmCommonTargetGenerator(target) - , MacOSXContentGenerator(0) - , OSXBundleGenerator(0) + , MacOSXContentGenerator(CM_NULLPTR) + , OSXBundleGenerator(CM_NULLPTR) , MacContentFolders() , LocalGenerator( static_cast<cmLocalNinjaGenerator*>(target->GetLocalGenerator())) @@ -321,7 +321,7 @@ void cmNinjaTargetGenerator::WriteCompileRule(const std::string& lang) std::string rspcontent; std::string responseFlag; - if (this->ForceResponseFile()) { + if (lang != "RC" && this->ForceResponseFile()) { rspfile = "$RSP_FILE"; responseFlag = "@" + rspfile; rspcontent = " $DEFINES $INCLUDES $FLAGS"; @@ -487,6 +487,10 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatements() this->GetLocalGenerator()->AppendTargetDepends(this->GeneratorTarget, orderOnlyDeps); + // Add order-only dependencies on other files associated with the target. + orderOnlyDeps.insert(orderOnlyDeps.end(), this->ExtraFiles.begin(), + this->ExtraFiles.end()); + // Add order-only dependencies on custom command outputs. for (std::vector<cmCustomCommand const*>::const_iterator cci = this->CustomCommands.begin(); @@ -599,7 +603,9 @@ void cmNinjaTargetGenerator::WriteObjectBuildStatement( this->SetMsvcTargetPdbVariable(vars); - int const commandLineLengthLimit = this->ForceResponseFile() ? -1 : 0; + bool const isRC = (language == "RC"); + int const commandLineLengthLimit = + ((!isRC && this->ForceResponseFile())) ? -1 : 0; std::string const rspfile = objectFileName + ".rsp"; this->GetGlobalGenerator()->WriteBuild( @@ -717,8 +723,8 @@ void cmNinjaTargetGenerator::MacOSXContentGeneratorType::operator()( this->Generator->GetGlobalGenerator()->WriteMacOSXContentBuild(input, output); - // Add as a dependency of all target so that it gets called. - this->Generator->GetGlobalGenerator()->AddDependencyToAll(output); + // Add as a dependency to the target so that it gets called. + this->Generator->ExtraFiles.push_back(output); } void cmNinjaTargetGenerator::addPoolNinjaVariable( @@ -735,5 +741,5 @@ bool cmNinjaTargetGenerator::ForceResponseFile() { static std::string const forceRspFile = "CMAKE_NINJA_FORCE_RESPONSE_FILE"; return (this->GetMakefile()->IsDefinitionSet(forceRspFile) || - cmSystemTools::GetEnv(forceRspFile) != 0); + cmSystemTools::GetEnv(forceRspFile) != CM_NULLPTR); } diff --git a/Source/cmNinjaTargetGenerator.h b/Source/cmNinjaTargetGenerator.h index 414aa09..9740f0e 100644 --- a/Source/cmNinjaTargetGenerator.h +++ b/Source/cmNinjaTargetGenerator.h @@ -37,7 +37,7 @@ public: cmNinjaTargetGenerator(cmGeneratorTarget* target); /// Destructor. - virtual ~cmNinjaTargetGenerator(); + ~cmNinjaTargetGenerator() CM_OVERRIDE; virtual void Generate() = 0; @@ -79,7 +79,8 @@ protected: std::string ComputeFlagsForObject(cmSourceFile const* source, const std::string& language); - void AddIncludeFlags(std::string& flags, std::string const& lang); + void AddIncludeFlags(std::string& flags, + std::string const& lang) CM_OVERRIDE; std::string ComputeDefines(cmSourceFile const* source, const std::string& language); @@ -134,7 +135,8 @@ protected: { } - void operator()(cmSourceFile const& source, const char* pkgloc); + void operator()(cmSourceFile const& source, + const char* pkgloc) CM_OVERRIDE; private: cmNinjaTargetGenerator* Generator; @@ -156,6 +158,7 @@ private: /// List of object files for this target. cmNinjaDeps Objects; std::vector<cmCustomCommand const*> CustomCommands; + cmNinjaDeps ExtraFiles; }; #endif // ! cmNinjaTargetGenerator_h diff --git a/Source/cmNinjaUtilityTargetGenerator.h b/Source/cmNinjaUtilityTargetGenerator.h index fec2946..0c33a54 100644 --- a/Source/cmNinjaUtilityTargetGenerator.h +++ b/Source/cmNinjaUtilityTargetGenerator.h @@ -23,9 +23,9 @@ class cmNinjaUtilityTargetGenerator : public cmNinjaTargetGenerator { public: cmNinjaUtilityTargetGenerator(cmGeneratorTarget* target); - ~cmNinjaUtilityTargetGenerator(); + ~cmNinjaUtilityTargetGenerator() CM_OVERRIDE; - void Generate(); + void Generate() CM_OVERRIDE; }; #endif // ! cmNinjaUtilityTargetGenerator_h diff --git a/Source/cmOSXBundleGenerator.cxx b/Source/cmOSXBundleGenerator.cxx index c19cae0..dbfe6eb 100644 --- a/Source/cmOSXBundleGenerator.cxx +++ b/Source/cmOSXBundleGenerator.cxx @@ -23,7 +23,7 @@ cmOSXBundleGenerator::cmOSXBundleGenerator(cmGeneratorTarget* target, , Makefile(target->Target->GetMakefile()) , LocalGenerator(target->GetLocalGenerator()) , ConfigName(configName) - , MacContentFolders(0) + , MacContentFolders(CM_NULLPTR) { if (this->MustSkip()) { return; diff --git a/Source/cmOptionCommand.h b/Source/cmOptionCommand.h index 491f45e..6e6b076 100644 --- a/Source/cmOptionCommand.h +++ b/Source/cmOptionCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmOptionCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmOptionCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "option"; } + std::string GetName() const CM_OVERRIDE { return "option"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmOptionCommand, cmCommand); }; diff --git a/Source/cmOrderDirectories.cxx b/Source/cmOrderDirectories.cxx index 00606c7..20f2246 100644 --- a/Source/cmOrderDirectories.cxx +++ b/Source/cmOrderDirectories.cxx @@ -157,7 +157,7 @@ public: } } - virtual void Report(std::ostream& e) + void Report(std::ostream& e) CM_OVERRIDE { e << "runtime library ["; if (this->SOName.empty()) { @@ -168,7 +168,7 @@ public: e << "]"; } - virtual bool FindConflict(std::string const& dir); + bool FindConflict(std::string const& dir) CM_OVERRIDE; private: // The soname of the shared library if it is known. @@ -212,12 +212,12 @@ public: { } - virtual void Report(std::ostream& e) + void Report(std::ostream& e) CM_OVERRIDE { e << "link library [" << this->FileName << "]"; } - virtual bool FindConflict(std::string const& dir); + bool FindConflict(std::string const& dir) CM_OVERRIDE; }; bool cmOrderDirectoriesConstraintLibrary::FindConflict(std::string const& dir) diff --git a/Source/cmOrderDirectories.h b/Source/cmOrderDirectories.h index fc1a388..38e197c 100644 --- a/Source/cmOrderDirectories.h +++ b/Source/cmOrderDirectories.h @@ -30,7 +30,8 @@ public: cmOrderDirectories(cmGlobalGenerator* gg, cmGeneratorTarget const* target, const char* purpose); ~cmOrderDirectories(); - void AddRuntimeLibrary(std::string const& fullPath, const char* soname = 0); + void AddRuntimeLibrary(std::string const& fullPath, + const char* soname = CM_NULLPTR); void AddLinkLibrary(std::string const& fullPath); void AddUserDirectories(std::vector<std::string> const& extra); void AddLanguageDirectories(std::vector<std::string> const& dirs); diff --git a/Source/cmOutputConverter.cxx b/Source/cmOutputConverter.cxx index b92c074..411184c 100644 --- a/Source/cmOutputConverter.cxx +++ b/Source/cmOutputConverter.cxx @@ -54,7 +54,7 @@ std::string cmOutputConverter::ConvertToOutputForExisting( assert(remote != NONE); const char* remotePath = this->GetRelativeRootPath(remote); - assert(remotePath != 0); + assert(remotePath != CM_NULLPTR); return this->ConvertToOutputForExisting(remotePath, format); } @@ -73,7 +73,7 @@ const char* cmOutputConverter::GetRelativeRootPath(RelativeRoot relroot) const default: break; } - return 0; + return CM_NULLPTR; } std::string cmOutputConverter::Convert(const std::string& source, @@ -155,7 +155,7 @@ std::string cmOutputConverter::Convert(RelativeRoot remote, assert(remote != NONE); const char* remotePath = this->GetRelativeRootPath(remote); - assert(remotePath != 0); + assert(remotePath != CM_NULLPTR); if (local.empty()) { return this->ConvertToOutputFormat(remotePath, output); diff --git a/Source/cmOutputRequiredFilesCommand.cxx b/Source/cmOutputRequiredFilesCommand.cxx index 29f1acc..ef636e7 100644 --- a/Source/cmOutputRequiredFilesCommand.cxx +++ b/Source/cmOutputRequiredFilesCommand.cxx @@ -28,7 +28,7 @@ public: */ cmDependInformation() : DependDone(false) - , SourceFile(0) + , SourceFile(CM_NULLPTR) { } @@ -154,7 +154,7 @@ public: */ const cmDependInformation* FindDependencies(const char* file) { - cmDependInformation* info = this->GetDependInformation(file, 0); + cmDependInformation* info = this->GetDependInformation(file, CM_NULLPTR); this->GenerateDependInformation(info); return info; } @@ -203,7 +203,7 @@ protected: message += includeFile; message += " for file "; message += info->FullPath.c_str(); - cmSystemTools::Error(message.c_str(), 0); + cmSystemTools::Error(message.c_str(), CM_NULLPTR); } continue; } @@ -329,7 +329,7 @@ protected: // See if the cmSourceFile for it has any files specified as // dependency hints. - if (info->SourceFile != 0) { + if (info->SourceFile != CM_NULLPTR) { // Get the cmSourceFile corresponding to this. const cmSourceFile& cFile = *(info->SourceFile); diff --git a/Source/cmOutputRequiredFilesCommand.h b/Source/cmOutputRequiredFilesCommand.h index 7a6f5a6..8838d09 100644 --- a/Source/cmOutputRequiredFilesCommand.h +++ b/Source/cmOutputRequiredFilesCommand.h @@ -20,10 +20,10 @@ class cmOutputRequiredFilesCommand : public cmCommand { public: cmTypeMacro(cmOutputRequiredFilesCommand, cmCommand); - virtual cmCommand* Clone() { return new cmOutputRequiredFilesCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "output_required_files"; } + cmCommand* Clone() CM_OVERRIDE { return new cmOutputRequiredFilesCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "output_required_files"; } void ListDependencies(cmDependInformation const* info, FILE* fout, std::set<cmDependInformation const*>* visited); diff --git a/Source/cmParseArgumentsCommand.h b/Source/cmParseArgumentsCommand.h index 46d9daa..fcd9992 100644 --- a/Source/cmParseArgumentsCommand.h +++ b/Source/cmParseArgumentsCommand.h @@ -24,24 +24,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmParseArgumentsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmParseArgumentsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "cmake_parse_arguments"; } + std::string GetName() const CM_OVERRIDE { return "cmake_parse_arguments"; } cmTypeMacro(cmParseArgumentsCommand, cmCommand); }; diff --git a/Source/cmPolicies.cxx b/Source/cmPolicies.cxx index 85f0fa3..124fb6a 100644 --- a/Source/cmPolicies.cxx +++ b/Source/cmPolicies.cxx @@ -57,9 +57,9 @@ static const char* idToString(cmPolicies::PolicyID id) CM_FOR_EACH_POLICY_ID(POLICY_CASE) #undef POLICY_CASE case cmPolicies::CMPCOUNT: - return 0; + return CM_NULLPTR; } - return 0; + return CM_NULLPTR; } static const char* idToVersion(cmPolicies::PolicyID id) @@ -71,9 +71,9 @@ static const char* idToVersion(cmPolicies::PolicyID id) CM_FOR_EACH_POLICY_ID_VERSION(POLICY_CASE) #undef POLICY_CASE case cmPolicies::CMPCOUNT: - return 0; + return CM_NULLPTR; } - return 0; + return CM_NULLPTR; } static bool isPolicyNewerThan(cmPolicies::PolicyID id, unsigned int majorV, @@ -102,9 +102,9 @@ const char* idToShortDescription(cmPolicies::PolicyID id) CM_FOR_EACH_POLICY_ID_DOC(POLICY_CASE) #undef POLICY_CASE case cmPolicies::CMPCOUNT: - return 0; + return CM_NULLPTR; } - return 0; + return CM_NULLPTR; } static void DiagnoseAncientPolicies( diff --git a/Source/cmPolicies.h b/Source/cmPolicies.h index ff49e31..0c8ff60 100644 --- a/Source/cmPolicies.h +++ b/Source/cmPolicies.h @@ -203,7 +203,10 @@ class cmPolicy; SELECT(POLICY, CMP0065, \ "Do not add flags to export symbols from executables without " \ "the ENABLE_EXPORTS target property.", \ - 3, 4, 0, cmPolicies::WARN) + 3, 4, 0, cmPolicies::WARN) \ + SELECT(POLICY, CMP0066, \ + "Honor per-config flags in try_compile() source-file signature.", 3, \ + 7, 0, cmPolicies::WARN) #define CM_SELECT_ID(F, A1, A2, A3, A4, A5, A6) F(A1) #define CM_FOR_EACH_POLICY_ID(POLICY) \ diff --git a/Source/cmProcessTools.cxx b/Source/cmProcessTools.cxx index 446752e..34b8df2 100644 --- a/Source/cmProcessTools.cxx +++ b/Source/cmProcessTools.cxx @@ -17,27 +17,27 @@ void cmProcessTools::RunProcess(struct cmsysProcess_s* cp, OutputParser* out, OutputParser* err) { cmsysProcess_Execute(cp); - char* data = 0; + char* data = CM_NULLPTR; int length = 0; int p; while ((out || err) && - (p = cmsysProcess_WaitForData(cp, &data, &length, 0), p)) { + (p = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR), p)) { if (out && p == cmsysProcess_Pipe_STDOUT) { if (!out->Process(data, length)) { - out = 0; + out = CM_NULLPTR; } } else if (err && p == cmsysProcess_Pipe_STDERR) { if (!err->Process(data, length)) { - err = 0; + err = CM_NULLPTR; } } } - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); } cmProcessTools::LineParser::LineParser(char sep, bool ignoreCR) - : Log(0) - , Prefix(0) + : Log(CM_NULLPTR) + , Prefix(CM_NULLPTR) , Separator(sep) , LineEnd('\0') , IgnoreCR(ignoreCR) diff --git a/Source/cmProcessTools.h b/Source/cmProcessTools.h index a48e52b..61bfc64 100644 --- a/Source/cmProcessTools.h +++ b/Source/cmProcessTools.h @@ -62,7 +62,7 @@ public: char Separator; char LineEnd; bool IgnoreCR; - virtual bool ProcessChunk(const char* data, int length); + bool ProcessChunk(const char* data, int length) CM_OVERRIDE; /** Implement in a subclass to process one line of input. It should return true only if it is interested in more data. */ @@ -73,18 +73,18 @@ public: class OutputLogger : public LineParser { public: - OutputLogger(std::ostream& log, const char* prefix = 0) + OutputLogger(std::ostream& log, const char* prefix = CM_NULLPTR) { this->SetLog(&log, prefix); } private: - virtual bool ProcessLine() { return true; } + bool ProcessLine() CM_OVERRIDE { return true; } }; /** Run a process and send output to given parsers. */ static void RunProcess(struct cmsysProcess_s* cp, OutputParser* out, - OutputParser* err = 0); + OutputParser* err = CM_NULLPTR); }; #endif diff --git a/Source/cmProjectCommand.h b/Source/cmProjectCommand.h index a4e6367..3318df1 100644 --- a/Source/cmProjectCommand.h +++ b/Source/cmProjectCommand.h @@ -28,19 +28,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmProjectCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmProjectCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "project"; } + std::string GetName() const CM_OVERRIDE { return "project"; } cmTypeMacro(cmProjectCommand, cmCommand); }; diff --git a/Source/cmProperty.cxx b/Source/cmProperty.cxx index 4910616..133258f 100644 --- a/Source/cmProperty.cxx +++ b/Source/cmProperty.cxx @@ -33,5 +33,5 @@ const char* cmProperty::GetValue() const if (this->ValueHasBeenSet) { return this->Value.c_str(); } - return 0; + return CM_NULLPTR; } diff --git a/Source/cmPropertyMap.cxx b/Source/cmPropertyMap.cxx index de1281e..1e1ff91 100644 --- a/Source/cmPropertyMap.cxx +++ b/Source/cmPropertyMap.cxx @@ -70,7 +70,7 @@ const char* cmPropertyMap::GetPropertyValue(const std::string& name) const cmPropertyMap::const_iterator it = this->find(name); if (it == this->end()) { - return 0; + return CM_NULLPTR; } return it->second.GetValue(); } diff --git a/Source/cmQTWrapCPPCommand.cxx b/Source/cmQTWrapCPPCommand.cxx index f63672b..ef8255a 100644 --- a/Source/cmQTWrapCPPCommand.cxx +++ b/Source/cmQTWrapCPPCommand.cxx @@ -80,7 +80,7 @@ bool cmQTWrapCPPCommand::InitialPass(std::vector<std::string> const& args, depends.push_back(hname); std::string no_main_dependency = ""; - const char* no_working_dir = 0; + const char* no_working_dir = CM_NULLPTR; this->Makefile->AddCustomCommandToOutput( newName, depends, no_main_dependency, commandLines, "Qt Wrapped File", no_working_dir); diff --git a/Source/cmQTWrapCPPCommand.h b/Source/cmQTWrapCPPCommand.h index 2014828..78d5510 100644 --- a/Source/cmQTWrapCPPCommand.h +++ b/Source/cmQTWrapCPPCommand.h @@ -30,19 +30,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmQTWrapCPPCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmQTWrapCPPCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "qt_wrap_cpp"; } + std::string GetName() const CM_OVERRIDE { return "qt_wrap_cpp"; } }; #endif diff --git a/Source/cmQTWrapUICommand.cxx b/Source/cmQTWrapUICommand.cxx index 4c1da36..a948dd6 100644 --- a/Source/cmQTWrapUICommand.cxx +++ b/Source/cmQTWrapUICommand.cxx @@ -111,8 +111,8 @@ bool cmQTWrapUICommand::InitialPass(std::vector<std::string> const& args, std::vector<std::string> depends; depends.push_back(uiName); std::string no_main_dependency = ""; - const char* no_comment = 0; - const char* no_working_dir = 0; + const char* no_comment = CM_NULLPTR; + const char* no_working_dir = CM_NULLPTR; this->Makefile->AddCustomCommandToOutput( hName, depends, no_main_dependency, hCommandLines, no_comment, no_working_dir); diff --git a/Source/cmQTWrapUICommand.h b/Source/cmQTWrapUICommand.h index 48cfc77..a34a7bf 100644 --- a/Source/cmQTWrapUICommand.h +++ b/Source/cmQTWrapUICommand.h @@ -28,19 +28,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmQTWrapUICommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmQTWrapUICommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "qt_wrap_ui"; } + std::string GetName() const CM_OVERRIDE { return "qt_wrap_ui"; } }; #endif diff --git a/Source/cmQtAutoGeneratorInitializer.cxx b/Source/cmQtAutoGeneratorInitializer.cxx index 98851d6..4a63aad 100644 --- a/Source/cmQtAutoGeneratorInitializer.cxx +++ b/Source/cmQtAutoGeneratorInitializer.cxx @@ -195,7 +195,7 @@ static void SetupAutoMocTarget( cmMakefile* makefile = target->Target->GetMakefile(); const char* tmp = target->GetProperty("AUTOMOC_MOC_OPTIONS"); - std::string _moc_options = (tmp != 0 ? tmp : ""); + std::string _moc_options = (tmp != CM_NULLPTR ? tmp : ""); makefile->AddDefinition( "_moc_options", cmOutputConverter::EscapeForCMake(_moc_options).c_str()); makefile->AddDefinition( @@ -484,8 +484,9 @@ static std::string ListQt5RccInputs(cmSourceFile* sf, std::string rccStdOut; std::string rccStdErr; int retVal = 0; - bool result = cmSystemTools::RunSingleCommand( - command, &rccStdOut, &rccStdErr, &retVal, 0, cmSystemTools::OUTPUT_NONE); + bool result = + cmSystemTools::RunSingleCommand(command, &rccStdOut, &rccStdErr, &retVal, + CM_NULLPTR, cmSystemTools::OUTPUT_NONE); if (result && retVal == 0 && rccStdOut.find("--list") != std::string::npos) { hasDashDashList = true; @@ -505,8 +506,9 @@ static std::string ListQt5RccInputs(cmSourceFile* sf, std::string rccStdOut; std::string rccStdErr; int retVal = 0; - bool result = cmSystemTools::RunSingleCommand( - command, &rccStdOut, &rccStdErr, &retVal, 0, cmSystemTools::OUTPUT_NONE); + bool result = + cmSystemTools::RunSingleCommand(command, &rccStdOut, &rccStdErr, &retVal, + CM_NULLPTR, cmSystemTools::OUTPUT_NONE); if (!result || retVal) { std::ostringstream err; err << "AUTOGEN: error: Rcc list process for " << sf->GetFullPath() diff --git a/Source/cmQtAutoGenerators.cxx b/Source/cmQtAutoGenerators.cxx index 6a6d72f..4b40c08 100644 --- a/Source/cmQtAutoGenerators.cxx +++ b/Source/cmQtAutoGenerators.cxx @@ -34,8 +34,8 @@ static bool requiresMocing(const std::string& text, std::string& macroName) { // this simple check is much much faster than the regexp - if (strstr(text.c_str(), "Q_OBJECT") == NULL && - strstr(text.c_str(), "Q_GADGET") == NULL) { + if (strstr(text.c_str(), "Q_OBJECT") == CM_NULLPTR && + strstr(text.c_str(), "Q_GADGET") == CM_NULLPTR) { return false; } @@ -88,7 +88,7 @@ static std::string extractSubDir(const std::string& absPath, } cmQtAutoGenerators::cmQtAutoGenerators() - : Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != 0) + : Verbose(cmsys::SystemTools::GetEnv("VERBOSE") != CM_NULLPTR) , ColorOutput(true) , RunMocFailed(false) , RunUicFailed(false) @@ -155,7 +155,7 @@ bool cmQtAutoGenerators::Run(const std::string& targetDirectory, snapshot.GetDirectory().SetCurrentBinary(targetDirectory); snapshot.GetDirectory().SetCurrentSource(targetDirectory); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, snapshot)); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, snapshot)); gg.SetCurrentMakefile(mf.get()); this->ReadAutogenInfoFile(mf.get(), targetDirectory, config); @@ -588,7 +588,7 @@ void cmQtAutoGenerators::ParseCppFile( // first a simple string check for "moc" is *much* faster than the regexp, // and if the string search already fails, we don't have to try the // expensive regexp - if ((strstr(contentsString.c_str(), "moc") != NULL) && + if ((strstr(contentsString.c_str(), "moc") != CM_NULLPTR) && (mocIncludeRegExp.find(contentsString))) { // for every moc include in the file do { @@ -765,7 +765,7 @@ void cmQtAutoGenerators::StrictParseCppFile( // first a simple string check for "moc" is *much* faster than the regexp, // and if the string search already fails, we don't have to try the // expensive regexp - if ((strstr(contentsString.c_str(), "moc") != NULL) && + if ((strstr(contentsString.c_str(), "moc") != CM_NULLPTR) && (mocIncludeRegExp.find(contentsString))) { // for every moc include in the file do { @@ -879,7 +879,7 @@ void cmQtAutoGenerators::ParseForUic( const std::string realName = cmsys::SystemTools::GetRealPath(absFilename); matchOffset = 0; - if ((strstr(contentsString.c_str(), "ui_") != NULL) && + if ((strstr(contentsString.c_str(), "ui_") != CM_NULLPTR) && (uiIncludeRegExp.find(contentsString))) { do { const std::string currentUi = uiIncludeRegExp.match(1); diff --git a/Source/cmRemoveCommand.h b/Source/cmRemoveCommand.h index c226a54..1deff36 100644 --- a/Source/cmRemoveCommand.h +++ b/Source/cmRemoveCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmRemoveCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmRemoveCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "remove"; } + std::string GetName() const CM_OVERRIDE { return "remove"; } cmTypeMacro(cmRemoveCommand, cmCommand); }; diff --git a/Source/cmRemoveDefinitionsCommand.h b/Source/cmRemoveDefinitionsCommand.h index b440307..7fb2e5f 100644 --- a/Source/cmRemoveDefinitionsCommand.h +++ b/Source/cmRemoveDefinitionsCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmRemoveDefinitionsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmRemoveDefinitionsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "remove_definitions"; } + std::string GetName() const CM_OVERRIDE { return "remove_definitions"; } cmTypeMacro(cmRemoveDefinitionsCommand, cmCommand); }; diff --git a/Source/cmReturnCommand.h b/Source/cmReturnCommand.h index 44cd4c8..ddf3613 100644 --- a/Source/cmReturnCommand.h +++ b/Source/cmReturnCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmReturnCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmReturnCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "return"; } + std::string GetName() const CM_OVERRIDE { return "return"; } cmTypeMacro(cmReturnCommand, cmCommand); }; diff --git a/Source/cmScriptGenerator.cxx b/Source/cmScriptGenerator.cxx index 5fed107..b8aae5d 100644 --- a/Source/cmScriptGenerator.cxx +++ b/Source/cmScriptGenerator.cxx @@ -19,7 +19,7 @@ cmScriptGenerator::cmScriptGenerator( : RuntimeConfigVariable(config_var) , Configurations(configurations) , ConfigurationName("") - , ConfigurationTypes(0) + , ConfigurationTypes(CM_NULLPTR) , ActionsPerConfig(false) { } @@ -36,7 +36,7 @@ void cmScriptGenerator::Generate( this->ConfigurationTypes = &configurationTypes; this->GenerateScript(os); this->ConfigurationName = ""; - this->ConfigurationTypes = 0; + this->ConfigurationTypes = CM_NULLPTR; } static void cmScriptGeneratorEncodeConfig(const std::string& config, diff --git a/Source/cmSearchPath.cxx b/Source/cmSearchPath.cxx index a0cce12..ca3a57f 100644 --- a/Source/cmSearchPath.cxx +++ b/Source/cmSearchPath.cxx @@ -45,7 +45,7 @@ void cmSearchPath::AddPath(const std::string& path) void cmSearchPath::AddUserPath(const std::string& path) { - assert(this->FC != NULL); + assert(this->FC != CM_NULLPTR); std::vector<std::string> outPaths; @@ -80,7 +80,7 @@ void cmSearchPath::AddUserPath(const std::string& path) void cmSearchPath::AddCMakePath(const std::string& variable) { - assert(this->FC != NULL); + assert(this->FC != CM_NULLPTR); // Get a path from a CMake variable. if (const char* value = this->FC->Makefile->GetDefinition(variable)) { @@ -107,7 +107,7 @@ void cmSearchPath::AddEnvPath(const std::string& variable) void cmSearchPath::AddCMakePrefixPath(const std::string& variable) { - assert(this->FC != NULL); + assert(this->FC != CM_NULLPTR); // Get a path from a CMake variable. if (const char* value = this->FC->Makefile->GetDefinition(variable)) { @@ -172,7 +172,7 @@ void cmSearchPath::AddSuffixes(const std::vector<std::string>& suffixes) void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths, const char* base) { - assert(this->FC != NULL); + assert(this->FC != CM_NULLPTR); // default for programs std::string subdir = "bin"; @@ -213,7 +213,7 @@ void cmSearchPath::AddPrefixPaths(const std::vector<std::string>& paths, void cmSearchPath::AddPathInternal(const std::string& path, const char* base) { - assert(this->FC != NULL); + assert(this->FC != CM_NULLPTR); std::string collapsed = cmSystemTools::CollapseFullPath(path, base); diff --git a/Source/cmSearchPath.h b/Source/cmSearchPath.h index 835196f..65f703f 100644 --- a/Source/cmSearchPath.h +++ b/Source/cmSearchPath.h @@ -28,7 +28,7 @@ public: // cmSearchPath must be initialized from a valid pointer. The only reason // for the default is to allow it to be easily used in stl containers. // Attempting to initialize with a NULL value will fail an assertion - cmSearchPath(cmFindCommon* findCmd = 0); + cmSearchPath(cmFindCommon* findCmd = CM_NULLPTR); ~cmSearchPath(); const std::vector<std::string>& GetPaths() const { return this->Paths; } @@ -47,8 +47,8 @@ public: protected: void AddPrefixPaths(const std::vector<std::string>& paths, - const char* base = 0); - void AddPathInternal(const std::string& path, const char* base = 0); + const char* base = CM_NULLPTR); + void AddPathInternal(const std::string& path, const char* base = CM_NULLPTR); cmFindCommon* FC; std::vector<std::string> Paths; diff --git a/Source/cmSeparateArgumentsCommand.h b/Source/cmSeparateArgumentsCommand.h index 47246c9..3c9e7d7 100644 --- a/Source/cmSeparateArgumentsCommand.h +++ b/Source/cmSeparateArgumentsCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmSeparateArgumentsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSeparateArgumentsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "separate_arguments"; } + std::string GetName() const CM_OVERRIDE { return "separate_arguments"; } cmTypeMacro(cmSeparateArgumentsCommand, cmCommand); }; diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx index 5f4cfee..1484368 100644 --- a/Source/cmSetCommand.cxx +++ b/Source/cmSetCommand.cxx @@ -59,7 +59,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args, // SET (VAR PARENT_SCOPE) // Removes the definition of VAR // in the parent scope. else if (args.size() == 2 && args[args.size() - 1] == "PARENT_SCOPE") { - this->Makefile->RaiseScope(variable, 0); + this->Makefile->RaiseScope(variable, CM_NULLPTR); return true; } @@ -73,7 +73,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args, bool force = false; // optional bool parentScope = false; cmState::CacheEntryType type = cmState::STRING; // required if cache - const char* docstring = 0; // required if cache + const char* docstring = CM_NULLPTR; // required if cache unsigned int ignoreLastArgs = 0; // look for PARENT_SCOPE argument diff --git a/Source/cmSetCommand.h b/Source/cmSetCommand.h index 65af8ac..b51eed0 100644 --- a/Source/cmSetCommand.h +++ b/Source/cmSetCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmSetCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSetCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set"; } + std::string GetName() const CM_OVERRIDE { return "set"; } cmTypeMacro(cmSetCommand, cmCommand); }; diff --git a/Source/cmSetDirectoryPropertiesCommand.h b/Source/cmSetDirectoryPropertiesCommand.h index a393eee..ef476ec 100644 --- a/Source/cmSetDirectoryPropertiesCommand.h +++ b/Source/cmSetDirectoryPropertiesCommand.h @@ -17,24 +17,30 @@ class cmSetDirectoryPropertiesCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmSetDirectoryPropertiesCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmSetDirectoryPropertiesCommand; + } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_directory_properties"; } + std::string GetName() const CM_OVERRIDE + { + return "set_directory_properties"; + } /** * Static entry point for use by other commands diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx index 73f7437..8fe8ade 100644 --- a/Source/cmSetPropertyCommand.cxx +++ b/Source/cmSetPropertyCommand.cxx @@ -139,7 +139,7 @@ bool cmSetPropertyCommand::HandleGlobalMode() const char* name = this->PropertyName.c_str(); const char* value = this->PropertyValue.c_str(); if (this->Remove) { - value = 0; + value = CM_NULLPTR; } if (this->AppendMode) { cm->AppendProperty(name, value ? value : "", this->AppendAsString); @@ -189,7 +189,7 @@ bool cmSetPropertyCommand::HandleDirectoryMode() const char* name = this->PropertyName.c_str(); const char* value = this->PropertyValue.c_str(); if (this->Remove) { - value = 0; + value = CM_NULLPTR; } if (this->AppendMode) { mf->AppendProperty(name, value ? value : "", this->AppendAsString); @@ -230,7 +230,7 @@ bool cmSetPropertyCommand::HandleTarget(cmTarget* target) const char* name = this->PropertyName.c_str(); const char* value = this->PropertyValue.c_str(); if (this->Remove) { - value = 0; + value = CM_NULLPTR; } if (this->AppendMode) { target->AppendProperty(name, value, this->AppendAsString); @@ -269,7 +269,7 @@ bool cmSetPropertyCommand::HandleSource(cmSourceFile* sf) const char* name = this->PropertyName.c_str(); const char* value = this->PropertyValue.c_str(); if (this->Remove) { - value = 0; + value = CM_NULLPTR; } if (this->AppendMode) { @@ -317,7 +317,7 @@ bool cmSetPropertyCommand::HandleTest(cmTest* test) const char* name = this->PropertyName.c_str(); const char* value = this->PropertyValue.c_str(); if (this->Remove) { - value = 0; + value = CM_NULLPTR; } if (this->AppendMode) { test->AppendProperty(name, value, this->AppendAsString); diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h index a85d652..e78b04c 100644 --- a/Source/cmSetPropertyCommand.h +++ b/Source/cmSetPropertyCommand.h @@ -19,24 +19,24 @@ class cmSetPropertyCommand : public cmCommand public: cmSetPropertyCommand(); - virtual cmCommand* Clone() { return new cmSetPropertyCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSetPropertyCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_property"; } + std::string GetName() const CM_OVERRIDE { return "set_property"; } /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } cmTypeMacro(cmSetPropertyCommand, cmCommand); diff --git a/Source/cmSetSourceFilesPropertiesCommand.h b/Source/cmSetSourceFilesPropertiesCommand.h index 20e6b93..f6b4de0 100644 --- a/Source/cmSetSourceFilesPropertiesCommand.h +++ b/Source/cmSetSourceFilesPropertiesCommand.h @@ -17,19 +17,25 @@ class cmSetSourceFilesPropertiesCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmSetSourceFilesPropertiesCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmSetSourceFilesPropertiesCommand; + } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_source_files_properties"; } + std::string GetName() const CM_OVERRIDE + { + return "set_source_files_properties"; + } cmTypeMacro(cmSetSourceFilesPropertiesCommand, cmCommand); diff --git a/Source/cmSetTargetPropertiesCommand.h b/Source/cmSetTargetPropertiesCommand.h index 122c15e..1ed8d90 100644 --- a/Source/cmSetTargetPropertiesCommand.h +++ b/Source/cmSetTargetPropertiesCommand.h @@ -17,19 +17,19 @@ class cmSetTargetPropertiesCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmSetTargetPropertiesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSetTargetPropertiesCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_target_properties"; } + std::string GetName() const CM_OVERRIDE { return "set_target_properties"; } /** * Used by this command and cmSetPropertiesCommand diff --git a/Source/cmSetTestsPropertiesCommand.h b/Source/cmSetTestsPropertiesCommand.h index e469b2a..712ab36 100644 --- a/Source/cmSetTestsPropertiesCommand.h +++ b/Source/cmSetTestsPropertiesCommand.h @@ -17,19 +17,19 @@ class cmSetTestsPropertiesCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmSetTestsPropertiesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSetTestsPropertiesCommand; } /** * This is called when the command is first encountered in * the input file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "set_tests_properties"; } + std::string GetName() const CM_OVERRIDE { return "set_tests_properties"; } cmTypeMacro(cmSetTestsPropertiesCommand, cmCommand); diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx index 702af4d..5c14991 100644 --- a/Source/cmSiteNameCommand.cxx +++ b/Source/cmSiteNameCommand.cxx @@ -55,7 +55,8 @@ bool cmSiteNameCommand::InitialPass(std::vector<std::string> const& args, // try to find the hostname for this computer if (!cmSystemTools::IsOff(hostname_cmd.c_str())) { std::string host; - cmSystemTools::RunSingleCommand(hostname_cmd.c_str(), &host, 0, 0, 0, + cmSystemTools::RunSingleCommand(hostname_cmd.c_str(), &host, CM_NULLPTR, + CM_NULLPTR, CM_NULLPTR, cmSystemTools::OUTPUT_NONE); // got the hostname diff --git a/Source/cmSiteNameCommand.h b/Source/cmSiteNameCommand.h index a4812f7..7a9ca9d 100644 --- a/Source/cmSiteNameCommand.h +++ b/Source/cmSiteNameCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmSiteNameCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSiteNameCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "site_name"; } + std::string GetName() const CM_OVERRIDE { return "site_name"; } cmTypeMacro(cmSiteNameCommand, cmCommand); }; diff --git a/Source/cmSourceFile.cxx b/Source/cmSourceFile.cxx index 5b0acee..04727b2 100644 --- a/Source/cmSourceFile.cxx +++ b/Source/cmSourceFile.cxx @@ -19,7 +19,7 @@ cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name) : Location(mf, name) { - this->CustomCommand = 0; + this->CustomCommand = CM_NULLPTR; this->FindFullPathFailed = false; this->IsUiFile = (".ui" == cmSystemTools::GetFilenameLastExtension( this->Location.GetName())); @@ -27,7 +27,7 @@ cmSourceFile::cmSourceFile(cmMakefile* mf, const std::string& name) cmSourceFile::~cmSourceFile() { - this->SetCustomCommand(0); + this->SetCustomCommand(CM_NULLPTR); } std::string const& cmSourceFile::GetExtension() const @@ -135,7 +135,7 @@ bool cmSourceFile::FindFullPath(std::string* error) // The file is not generated. It must exist on disk. cmMakefile const* mf = this->Location.GetMakefile(); - const char* tryDirs[3] = { 0, 0, 0 }; + const char* tryDirs[3] = { CM_NULLPTR, CM_NULLPTR, CM_NULLPTR }; if (this->Location.DirectoryIsAmbiguous()) { tryDirs[0] = mf->GetCurrentSourceDirectory(); tryDirs[1] = mf->GetCurrentBinaryDirectory(); @@ -294,7 +294,7 @@ const char* cmSourceFile::GetProperty(const std::string& prop) const // Check for computed properties. if (prop == "LOCATION") { if (this->FullPath.empty()) { - return 0; + return CM_NULLPTR; } else { return this->FullPath.c_str(); } diff --git a/Source/cmSourceFile.h b/Source/cmSourceFile.h index b1623bd..a3808f7 100644 --- a/Source/cmSourceFile.h +++ b/Source/cmSourceFile.h @@ -62,7 +62,7 @@ public: * horrible interface, but is necessary for backwards * compatibility). */ - std::string const& GetFullPath(std::string* error = 0); + std::string const& GetFullPath(std::string* error = CM_NULLPTR); std::string const& GetFullPath() const; /** diff --git a/Source/cmSourceFileLocation.cxx b/Source/cmSourceFileLocation.cxx index a89d1e8..099a6f0 100644 --- a/Source/cmSourceFileLocation.cxx +++ b/Source/cmSourceFileLocation.cxx @@ -19,7 +19,7 @@ #include "assert.h" cmSourceFileLocation::cmSourceFileLocation() - : Makefile(0) + : Makefile(CM_NULLPTR) , AmbiguousDirectory(true) , AmbiguousExtension(true) { diff --git a/Source/cmSourceGroup.cxx b/Source/cmSourceGroup.cxx index f27b572..d9529a2 100644 --- a/Source/cmSourceGroup.cxx +++ b/Source/cmSourceGroup.cxx @@ -123,7 +123,7 @@ cmSourceGroup* cmSourceGroup::LookupChild(const char* name) const } // if no child with this name was found return NULL - return NULL; + return CM_NULLPTR; } cmSourceGroup* cmSourceGroup::MatchChildrenFiles(const char* name) @@ -143,7 +143,7 @@ cmSourceGroup* cmSourceGroup::MatchChildrenFiles(const char* name) return result; } } - return 0; + return CM_NULLPTR; } cmSourceGroup* cmSourceGroup::MatchChildrenRegex(const char* name) @@ -164,7 +164,7 @@ cmSourceGroup* cmSourceGroup::MatchChildrenRegex(const char* name) return this; } - return 0; + return CM_NULLPTR; } std::vector<cmSourceGroup> const& cmSourceGroup::GetGroupChildren() const diff --git a/Source/cmSourceGroup.h b/Source/cmSourceGroup.h index 8603e95..1f5232e 100644 --- a/Source/cmSourceGroup.h +++ b/Source/cmSourceGroup.h @@ -34,7 +34,7 @@ class cmSourceGroup { public: cmSourceGroup(const char* name, const char* regex, - const char* parentName = 0); + const char* parentName = CM_NULLPTR); cmSourceGroup(cmSourceGroup const& r); ~cmSourceGroup(); cmSourceGroup& operator=(cmSourceGroup const&); diff --git a/Source/cmSourceGroupCommand.cxx b/Source/cmSourceGroupCommand.cxx index 252819c..6db14c0 100644 --- a/Source/cmSourceGroupCommand.cxx +++ b/Source/cmSourceGroupCommand.cxx @@ -28,7 +28,7 @@ bool cmSourceGroupCommand::InitialPass(std::vector<std::string> const& args, std::vector<std::string> folders = cmSystemTools::tokenize(args[0], delimiter); - cmSourceGroup* sg = 0; + cmSourceGroup* sg = CM_NULLPTR; sg = this->Makefile->GetSourceGroup(folders); if (!sg) { this->Makefile->AddSourceGroup(folders); diff --git a/Source/cmSourceGroupCommand.h b/Source/cmSourceGroupCommand.h index 0458656..81dfad6 100644 --- a/Source/cmSourceGroupCommand.h +++ b/Source/cmSourceGroupCommand.h @@ -26,19 +26,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmSourceGroupCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSourceGroupCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "source_group"; } + std::string GetName() const CM_OVERRIDE { return "source_group"; } cmTypeMacro(cmSourceGroupCommand, cmCommand); }; diff --git a/Source/cmState.cxx b/Source/cmState.cxx index d2cfaba..f2fe134 100644 --- a/Source/cmState.cxx +++ b/Source/cmState.cxx @@ -135,12 +135,12 @@ const char* cmState::GetTargetTypeName(cmState::TargetType targetType) return "UNKNOWN_LIBRARY"; } assert(0 && "Unexpected target type"); - return 0; + return CM_NULLPTR; } const char* cmCacheEntryTypes[] = { "BOOL", "PATH", "FILEPATH", "STRING", "INTERNAL", "STATIC", - "UNINITIALIZED", 0 }; + "UNINITIALIZED", CM_NULLPTR }; const char* cmState::CacheEntryTypeToString(cmState::CacheEntryType type) { @@ -204,7 +204,7 @@ const char* cmState::GetCacheEntryValue(std::string const& key) const { cmCacheManager::CacheEntry* e = this->CacheManager->GetCacheEntry(key); if (!e) { - return 0; + return CM_NULLPTR; } return e->Value.c_str(); } @@ -260,7 +260,7 @@ const char* cmState::GetCacheEntryProperty(std::string const& key, cmCacheManager::CacheIterator it = this->CacheManager->GetCacheIterator(key.c_str()); if (!it.PropertyExists(propertyName)) { - return 0; + return CM_NULLPTR; } return it.GetProperty(propertyName); } @@ -296,7 +296,7 @@ void cmState::RemoveCacheEntryProperty(std::string const& key, std::string const& propertyName) { this->CacheManager->GetCacheIterator(key.c_str()) - .SetProperty(propertyName, (void*)0); + .SetProperty(propertyName, (void*)CM_NULLPTR); } cmState::Snapshot cmState::Reset() @@ -374,7 +374,7 @@ cmPropertyDefinition const* cmState::GetPropertyDefinition( this->PropertyDefinitions.find(scope)->second; return &defs.find(name)->second; } - return 0; + return CM_NULLPTR; } bool cmState::IsPropertyDefined(const std::string& name, @@ -491,7 +491,7 @@ void cmState::RemoveUnscriptableCommands() cmCommand* cmState::GetCommand(std::string const& name) const { - cmCommand* command = 0; + cmCommand* command = CM_NULLPTR; std::string sName = cmSystemTools::LowerCase(name); std::map<std::string, cmCommand*>::const_iterator pos = this->Commands.find(sName); @@ -1197,7 +1197,7 @@ void cmState::Snapshot::SetDefinition(std::string const& name, void cmState::Snapshot::RemoveDefinition(std::string const& name) { - this->Position->Vars->Set(name, 0); + this->Position->Vars->Set(name, CM_NULLPTR); } std::vector<std::string> cmState::Snapshot::UnusedKeys() const diff --git a/Source/cmState.h b/Source/cmState.h index 935faec..e5f9917 100644 --- a/Source/cmState.h +++ b/Source/cmState.h @@ -55,7 +55,7 @@ public: class Snapshot { public: - Snapshot(cmState* state = 0); + Snapshot(cmState* state = CM_NULLPTR); Snapshot(cmState* state, PositionType position); const char* GetDefinition(std::string const& name) const; diff --git a/Source/cmStringCommand.cxx b/Source/cmStringCommand.cxx index a348aef..dce4687 100644 --- a/Source/cmStringCommand.cxx +++ b/Source/cmStringCommand.cxx @@ -89,7 +89,7 @@ bool cmStringCommand::HandleHashCommand(std::vector<std::string> const& args) return false; } - cmsys::auto_ptr<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); + CM_AUTO_PTR<cmCryptoHash> hash(cmCryptoHash::New(args[0].c_str())); if (hash.get()) { std::string out = hash->HashString(args[2]); this->Makefile->AddDefinition(args[1], out.c_str()); diff --git a/Source/cmStringCommand.h b/Source/cmStringCommand.h index 23d482c..23dc9db 100644 --- a/Source/cmStringCommand.h +++ b/Source/cmStringCommand.h @@ -29,24 +29,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmStringCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmStringCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "string"; } + std::string GetName() const CM_OVERRIDE { return "string"; } cmTypeMacro(cmStringCommand, cmCommand); diff --git a/Source/cmSubdirCommand.h b/Source/cmSubdirCommand.h index 9da91c4..08eb9a0 100644 --- a/Source/cmSubdirCommand.h +++ b/Source/cmSubdirCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmSubdirCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmSubdirCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "subdirs"; } + std::string GetName() const CM_OVERRIDE { return "subdirs"; } cmTypeMacro(cmSubdirCommand, cmCommand); }; diff --git a/Source/cmSubdirDependsCommand.h b/Source/cmSubdirDependsCommand.h index a15ee3e..41b27c8 100644 --- a/Source/cmSubdirDependsCommand.h +++ b/Source/cmSubdirDependsCommand.h @@ -17,10 +17,10 @@ class cmSubdirDependsCommand : public cmCommand { public: - virtual cmCommand* Clone() { return new cmSubdirDependsCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "subdir_depends"; } + cmCommand* Clone() CM_OVERRIDE { return new cmSubdirDependsCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "subdir_depends"; } cmTypeMacro(cmSubdirDependsCommand, cmCommand); }; diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx index 26cbfb6..2d463f3 100644 --- a/Source/cmSystemTools.cxx +++ b/Source/cmSystemTools.cxx @@ -583,7 +583,7 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command, a != command.end(); ++a) { argv.push_back(a->c_str()); } - argv.push_back(0); + argv.push_back(CM_NULLPTR); cmsysProcess* cp = cmsysProcess_New(); cmsysProcess_SetCommand(cp, &*argv.begin()); @@ -595,12 +595,12 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command, if (outputflag == OUTPUT_PASSTHROUGH) { cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDOUT, 1); cmsysProcess_SetPipeShared(cp, cmsysProcess_Pipe_STDERR, 1); - captureStdOut = 0; - captureStdErr = 0; + captureStdOut = CM_NULLPTR; + captureStdErr = CM_NULLPTR; } else if (outputflag == OUTPUT_MERGE || (captureStdErr && captureStdErr == captureStdOut)) { cmsysProcess_SetOption(cp, cmsysProcess_Option_MergeOutput, 1); - captureStdErr = 0; + captureStdErr = CM_NULLPTR; } assert(!captureStdErr || captureStdErr != captureStdOut); @@ -614,7 +614,8 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command, int pipe; if (outputflag != OUTPUT_PASSTHROUGH && (captureStdOut || captureStdErr || outputflag != OUTPUT_NONE)) { - while ((pipe = cmsysProcess_WaitForData(cp, &data, &length, 0)) > 0) { + while ((pipe = cmsysProcess_WaitForData(cp, &data, &length, CM_NULLPTR)) > + 0) { // Translate NULL characters in the output into valid text. // Visual Studio 7 puts these characters in the output of its // build process. @@ -642,7 +643,7 @@ bool cmSystemTools::RunSingleCommand(std::vector<std::string> const& command, } } - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); if (captureStdOut) { captureStdOut->assign(tempStdOut.begin(), tempStdOut.end()); } @@ -1432,7 +1433,7 @@ void list_item_verbose(FILE* out, struct archive_entry* entry) /* Use uname if it's present, else uid. */ p = archive_entry_uname(entry); - if ((p == NULL) || (*p == '\0')) { + if ((p == CM_NULLPTR) || (*p == '\0')) { sprintf(tmp, "%lu ", (unsigned long)archive_entry_uid(entry)); p = tmp; } @@ -1443,7 +1444,7 @@ void list_item_verbose(FILE* out, struct archive_entry* entry) fprintf(out, "%-*s ", (int)u_width, p); /* Use gname if it's present, else gid. */ p = archive_entry_gname(entry); - if (p != NULL && p[0] != '\0') { + if (p != CM_NULLPTR && p[0] != '\0') { fprintf(out, "%s", p); w = strlen(p); } else { @@ -1875,7 +1876,7 @@ unsigned int cmSystemTools::RandomSeed() // Try using a real random source. cmsys::ifstream fin; - fin.rdbuf()->pubsetbuf(0, 0); // Unbuffered read. + fin.rdbuf()->pubsetbuf(CM_NULLPTR, 0); // Unbuffered read. fin.open("/dev/urandom"); if (fin.good() && fin.read(seed.bytes, sizeof(seed)) && fin.gcount() == sizeof(seed)) { @@ -1884,7 +1885,7 @@ unsigned int cmSystemTools::RandomSeed() // Fall back to the time and pid. struct timeval t; - gettimeofday(&t, 0); + gettimeofday(&t, CM_NULLPTR); unsigned int pid = static_cast<unsigned int>(getpid()); unsigned int tv_sec = static_cast<unsigned int>(t.tv_sec); unsigned int tv_usec = static_cast<unsigned int>(t.tv_usec); @@ -2199,8 +2200,8 @@ bool cmSystemTools::ChangeRPath(std::string const& file, // Get the RPATH and RUNPATH entries from it. int se_count = 0; - cmELF::StringEntry const* se[2] = { 0, 0 }; - const char* se_name[2] = { 0, 0 }; + cmELF::StringEntry const* se[2] = { CM_NULLPTR, CM_NULLPTR }; + const char* se_name[2] = { CM_NULLPTR, CM_NULLPTR }; if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) { se[se_count] = se_rpath; se_name[se_count] = "RPATH"; @@ -2430,7 +2431,7 @@ bool cmSystemTools::RemoveRPath(std::string const& file, std::string* emsg, // Get the RPATH and RUNPATH entries from it and sort them by index // in the dynamic section header. int se_count = 0; - cmELF::StringEntry const* se[2] = { 0, 0 }; + cmELF::StringEntry const* se[2] = { CM_NULLPTR, CM_NULLPTR }; if (cmELF::StringEntry const* se_rpath = elf.GetRPath()) { se[se_count++] = se_rpath; } diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h index df2c1f7..39e7994 100644 --- a/Source/cmSystemTools.h +++ b/Source/cmSystemTools.h @@ -64,33 +64,35 @@ public: * title as a const char*, and a reference to bool that when * set to false, will disable furthur messages (cancel). */ - static void SetMessageCallback(MessageCallback f, void* clientData = 0); + static void SetMessageCallback(MessageCallback f, + void* clientData = CM_NULLPTR); /** * Display an error message. */ - static void Error(const char* m, const char* m2 = 0, const char* m3 = 0, - const char* m4 = 0); + static void Error(const char* m, const char* m2 = CM_NULLPTR, + const char* m3 = CM_NULLPTR, const char* m4 = CM_NULLPTR); /** * Display a message. */ - static void Message(const char* m, const char* title = 0); + static void Message(const char* m, const char* title = CM_NULLPTR); typedef void (*OutputCallback)(const char*, size_t length, void*); ///! Send a string to stdout static void Stdout(const char* s); static void Stdout(const char* s, size_t length); - static void SetStdoutCallback(OutputCallback, void* clientData = 0); + static void SetStdoutCallback(OutputCallback, void* clientData = CM_NULLPTR); ///! Send a string to stderr static void Stderr(const char* s); static void Stderr(const char* s, size_t length); - static void SetStderrCallback(OutputCallback, void* clientData = 0); + static void SetStderrCallback(OutputCallback, void* clientData = CM_NULLPTR); typedef bool (*InterruptCallback)(void*); - static void SetInterruptCallback(InterruptCallback f, void* clientData = 0); + static void SetInterruptCallback(InterruptCallback f, + void* clientData = CM_NULLPTR); static bool GetInterruptFlag(); ///! Return true if there was an error at any point. @@ -220,9 +222,10 @@ public: OUTPUT_PASSTHROUGH }; static bool RunSingleCommand(const char* command, - std::string* captureStdOut = 0, - std::string* captureStdErr = 0, int* retVal = 0, - const char* dir = 0, + std::string* captureStdOut = CM_NULLPTR, + std::string* captureStdErr = CM_NULLPTR, + int* retVal = CM_NULLPTR, + const char* dir = CM_NULLPTR, OutputOption outputflag = OUTPUT_MERGE, double timeout = 0.0); /** @@ -231,9 +234,10 @@ public: * be in comand[1]...command[command.size()] */ static bool RunSingleCommand(std::vector<std::string> const& command, - std::string* captureStdOut = 0, - std::string* captureStdErr = 0, int* retVal = 0, - const char* dir = 0, + std::string* captureStdOut = CM_NULLPTR, + std::string* captureStdErr = CM_NULLPTR, + int* retVal = CM_NULLPTR, + const char* dir = CM_NULLPTR, OutputOption outputflag = OUTPUT_MERGE, double timeout = 0.0); @@ -435,12 +439,14 @@ public: /** Try to set the RPATH in an ELF binary. */ static bool ChangeRPath(std::string const& file, std::string const& oldRPath, - std::string const& newRPath, std::string* emsg = 0, - bool* changed = 0); + std::string const& newRPath, + std::string* emsg = CM_NULLPTR, + bool* changed = CM_NULLPTR); /** Try to remove the RPATH from an ELF binary. */ - static bool RemoveRPath(std::string const& file, std::string* emsg = 0, - bool* removed = 0); + static bool RemoveRPath(std::string const& file, + std::string* emsg = CM_NULLPTR, + bool* removed = CM_NULLPTR); /** Check whether the RPATH in an ELF binary contains the path given. */ diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx index 4386080..ceebf93 100644 --- a/Source/cmTarget.cxx +++ b/Source/cmTarget.cxx @@ -27,7 +27,11 @@ #include <map> #include <set> #include <stdlib.h> // required for atof -#if defined(CMAKE_BUILD_WITH_CMAKE) + +#if defined(CMake_HAVE_CXX_UNORDERED_SET) +#include <unordered_set> +#define UNORDERED_SET std::unordered_set +#elif defined(CMAKE_BUILD_WITH_CMAKE) #include <cmsys/hash_set.hxx> #define UNORDERED_SET cmsys::hash_set #else @@ -53,7 +57,7 @@ public: cmTarget::cmTarget() { - this->Makefile = 0; + this->Makefile = CM_NULLPTR; this->HaveInstallRule = false; this->DLLPlatform = false; this->IsAndroid = false; @@ -93,64 +97,64 @@ void cmTarget::SetMakefile(cmMakefile* mf) // Setup default property values. if (this->GetType() != cmState::INTERFACE_LIBRARY && this->GetType() != cmState::UTILITY) { - this->SetPropertyDefault("ANDROID_API", 0); - this->SetPropertyDefault("ANDROID_API_MIN", 0); - this->SetPropertyDefault("ANDROID_ARCH", 0); - this->SetPropertyDefault("ANDROID_STL_TYPE", 0); - this->SetPropertyDefault("ANDROID_SKIP_ANT_STEP", 0); - this->SetPropertyDefault("ANDROID_PROCESS_MAX", 0); - this->SetPropertyDefault("ANDROID_PROGUARD", 0); - this->SetPropertyDefault("ANDROID_PROGUARD_CONFIG_PATH", 0); - this->SetPropertyDefault("ANDROID_SECURE_PROPS_PATH", 0); - this->SetPropertyDefault("ANDROID_NATIVE_LIB_DIRECTORIES", 0); - this->SetPropertyDefault("ANDROID_NATIVE_LIB_DEPENDENCIES", 0); - this->SetPropertyDefault("ANDROID_JAVA_SOURCE_DIR", 0); - this->SetPropertyDefault("ANDROID_JAR_DIRECTORIES", 0); - this->SetPropertyDefault("ANDROID_JAR_DEPENDENCIES", 0); - this->SetPropertyDefault("ANDROID_ASSETS_DIRECTORIES", 0); - this->SetPropertyDefault("ANDROID_ANT_ADDITIONAL_OPTIONS", 0); - this->SetPropertyDefault("INSTALL_NAME_DIR", 0); + this->SetPropertyDefault("ANDROID_API", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_API_MIN", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_ARCH", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_STL_TYPE", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_SKIP_ANT_STEP", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_PROCESS_MAX", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_PROGUARD", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_PROGUARD_CONFIG_PATH", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_SECURE_PROPS_PATH", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_NATIVE_LIB_DIRECTORIES", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_NATIVE_LIB_DEPENDENCIES", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_JAVA_SOURCE_DIR", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_JAR_DIRECTORIES", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_JAR_DEPENDENCIES", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_ASSETS_DIRECTORIES", CM_NULLPTR); + this->SetPropertyDefault("ANDROID_ANT_ADDITIONAL_OPTIONS", CM_NULLPTR); + this->SetPropertyDefault("INSTALL_NAME_DIR", CM_NULLPTR); this->SetPropertyDefault("INSTALL_RPATH", ""); this->SetPropertyDefault("INSTALL_RPATH_USE_LINK_PATH", "OFF"); this->SetPropertyDefault("SKIP_BUILD_RPATH", "OFF"); this->SetPropertyDefault("BUILD_WITH_INSTALL_RPATH", "OFF"); - this->SetPropertyDefault("ARCHIVE_OUTPUT_DIRECTORY", 0); - this->SetPropertyDefault("LIBRARY_OUTPUT_DIRECTORY", 0); - this->SetPropertyDefault("RUNTIME_OUTPUT_DIRECTORY", 0); - this->SetPropertyDefault("PDB_OUTPUT_DIRECTORY", 0); - this->SetPropertyDefault("COMPILE_PDB_OUTPUT_DIRECTORY", 0); - this->SetPropertyDefault("Fortran_FORMAT", 0); - this->SetPropertyDefault("Fortran_MODULE_DIRECTORY", 0); - this->SetPropertyDefault("GNUtoMS", 0); - this->SetPropertyDefault("OSX_ARCHITECTURES", 0); - this->SetPropertyDefault("IOS_INSTALL_COMBINED", 0); - this->SetPropertyDefault("AUTOMOC", 0); - this->SetPropertyDefault("AUTOUIC", 0); - this->SetPropertyDefault("AUTORCC", 0); - this->SetPropertyDefault("AUTOMOC_MOC_OPTIONS", 0); - this->SetPropertyDefault("AUTOUIC_OPTIONS", 0); - this->SetPropertyDefault("AUTORCC_OPTIONS", 0); - this->SetPropertyDefault("LINK_DEPENDS_NO_SHARED", 0); - this->SetPropertyDefault("LINK_INTERFACE_LIBRARIES", 0); - this->SetPropertyDefault("WIN32_EXECUTABLE", 0); - this->SetPropertyDefault("MACOSX_BUNDLE", 0); - this->SetPropertyDefault("MACOSX_RPATH", 0); - this->SetPropertyDefault("NO_SYSTEM_FROM_IMPORTED", 0); - this->SetPropertyDefault("C_CLANG_TIDY", 0); - this->SetPropertyDefault("C_COMPILER_LAUNCHER", 0); - this->SetPropertyDefault("C_INCLUDE_WHAT_YOU_USE", 0); - this->SetPropertyDefault("LINK_WHAT_YOU_USE", 0); - this->SetPropertyDefault("C_STANDARD", 0); - this->SetPropertyDefault("C_STANDARD_REQUIRED", 0); - this->SetPropertyDefault("C_EXTENSIONS", 0); - this->SetPropertyDefault("CXX_CLANG_TIDY", 0); - this->SetPropertyDefault("CXX_COMPILER_LAUNCHER", 0); - this->SetPropertyDefault("CXX_INCLUDE_WHAT_YOU_USE", 0); - this->SetPropertyDefault("CXX_STANDARD", 0); - this->SetPropertyDefault("CXX_STANDARD_REQUIRED", 0); - this->SetPropertyDefault("CXX_EXTENSIONS", 0); - this->SetPropertyDefault("LINK_SEARCH_START_STATIC", 0); - this->SetPropertyDefault("LINK_SEARCH_END_STATIC", 0); + this->SetPropertyDefault("ARCHIVE_OUTPUT_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("LIBRARY_OUTPUT_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("RUNTIME_OUTPUT_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("PDB_OUTPUT_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("COMPILE_PDB_OUTPUT_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("Fortran_FORMAT", CM_NULLPTR); + this->SetPropertyDefault("Fortran_MODULE_DIRECTORY", CM_NULLPTR); + this->SetPropertyDefault("GNUtoMS", CM_NULLPTR); + this->SetPropertyDefault("OSX_ARCHITECTURES", CM_NULLPTR); + this->SetPropertyDefault("IOS_INSTALL_COMBINED", CM_NULLPTR); + this->SetPropertyDefault("AUTOMOC", CM_NULLPTR); + this->SetPropertyDefault("AUTOUIC", CM_NULLPTR); + this->SetPropertyDefault("AUTORCC", CM_NULLPTR); + this->SetPropertyDefault("AUTOMOC_MOC_OPTIONS", CM_NULLPTR); + this->SetPropertyDefault("AUTOUIC_OPTIONS", CM_NULLPTR); + this->SetPropertyDefault("AUTORCC_OPTIONS", CM_NULLPTR); + this->SetPropertyDefault("LINK_DEPENDS_NO_SHARED", CM_NULLPTR); + this->SetPropertyDefault("LINK_INTERFACE_LIBRARIES", CM_NULLPTR); + this->SetPropertyDefault("WIN32_EXECUTABLE", CM_NULLPTR); + this->SetPropertyDefault("MACOSX_BUNDLE", CM_NULLPTR); + this->SetPropertyDefault("MACOSX_RPATH", CM_NULLPTR); + this->SetPropertyDefault("NO_SYSTEM_FROM_IMPORTED", CM_NULLPTR); + this->SetPropertyDefault("C_CLANG_TIDY", CM_NULLPTR); + this->SetPropertyDefault("C_COMPILER_LAUNCHER", CM_NULLPTR); + this->SetPropertyDefault("C_INCLUDE_WHAT_YOU_USE", CM_NULLPTR); + this->SetPropertyDefault("LINK_WHAT_YOU_USE", CM_NULLPTR); + this->SetPropertyDefault("C_STANDARD", CM_NULLPTR); + this->SetPropertyDefault("C_STANDARD_REQUIRED", CM_NULLPTR); + this->SetPropertyDefault("C_EXTENSIONS", CM_NULLPTR); + this->SetPropertyDefault("CXX_CLANG_TIDY", CM_NULLPTR); + this->SetPropertyDefault("CXX_COMPILER_LAUNCHER", CM_NULLPTR); + this->SetPropertyDefault("CXX_INCLUDE_WHAT_YOU_USE", CM_NULLPTR); + this->SetPropertyDefault("CXX_STANDARD", CM_NULLPTR); + this->SetPropertyDefault("CXX_STANDARD_REQUIRED", CM_NULLPTR); + this->SetPropertyDefault("CXX_EXTENSIONS", CM_NULLPTR); + this->SetPropertyDefault("LINK_SEARCH_START_STATIC", CM_NULLPTR); + this->SetPropertyDefault("LINK_SEARCH_END_STATIC", CM_NULLPTR); } // Collect the set of configuration types. @@ -167,7 +171,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) "PDB_OUTPUT_DIRECTORY_", "COMPILE_PDB_OUTPUT_DIRECTORY_", "MAP_IMPORTED_CONFIG_", - 0 + CM_NULLPTR }; for (std::vector<std::string>::iterator ci = configNames.begin(); ci != configNames.end(); ++ci) { @@ -179,7 +183,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) } std::string property = *p; property += configUpper; - this->SetPropertyDefault(property, 0); + this->SetPropertyDefault(property, CM_NULLPTR); } // Initialize per-configuration name postfix property from the @@ -191,7 +195,7 @@ void cmTarget::SetMakefile(cmMakefile* mf) this->TargetTypeValue != cmState::INTERFACE_LIBRARY) { std::string property = cmSystemTools::UpperCase(*ci); property += "_POSTFIX"; - this->SetPropertyDefault(property, 0); + this->SetPropertyDefault(property, CM_NULLPTR); } } } @@ -235,27 +239,27 @@ void cmTarget::SetMakefile(cmMakefile* mf) if (this->GetType() != cmState::INTERFACE_LIBRARY && this->GetType() != cmState::UTILITY) { - this->SetPropertyDefault("C_VISIBILITY_PRESET", 0); - this->SetPropertyDefault("CXX_VISIBILITY_PRESET", 0); - this->SetPropertyDefault("VISIBILITY_INLINES_HIDDEN", 0); + this->SetPropertyDefault("C_VISIBILITY_PRESET", CM_NULLPTR); + this->SetPropertyDefault("CXX_VISIBILITY_PRESET", CM_NULLPTR); + this->SetPropertyDefault("VISIBILITY_INLINES_HIDDEN", CM_NULLPTR); } if (this->TargetTypeValue == cmState::EXECUTABLE) { - this->SetPropertyDefault("ANDROID_GUI", 0); - this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", 0); - this->SetPropertyDefault("ENABLE_EXPORTS", 0); + this->SetPropertyDefault("ANDROID_GUI", CM_NULLPTR); + this->SetPropertyDefault("CROSSCOMPILING_EMULATOR", CM_NULLPTR); + this->SetPropertyDefault("ENABLE_EXPORTS", CM_NULLPTR); } if (this->TargetTypeValue == cmState::SHARED_LIBRARY || this->TargetTypeValue == cmState::MODULE_LIBRARY) { this->SetProperty("POSITION_INDEPENDENT_CODE", "True"); } if (this->TargetTypeValue == cmState::SHARED_LIBRARY) { - this->SetPropertyDefault("WINDOWS_EXPORT_ALL_SYMBOLS", 0); + this->SetPropertyDefault("WINDOWS_EXPORT_ALL_SYMBOLS", CM_NULLPTR); } if (this->GetType() != cmState::INTERFACE_LIBRARY && this->GetType() != cmState::UTILITY) { - this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", 0); + this->SetPropertyDefault("POSITION_INDEPENDENT_CODE", CM_NULLPTR); } // Record current policies for later use. @@ -270,8 +274,8 @@ void cmTarget::SetMakefile(cmMakefile* mf) if (this->GetType() != cmState::INTERFACE_LIBRARY && this->GetType() != cmState::UTILITY) { - this->SetPropertyDefault("JOB_POOL_COMPILE", 0); - this->SetPropertyDefault("JOB_POOL_LINK", 0); + this->SetPropertyDefault("JOB_POOL_COMPILE", CM_NULLPTR); + this->SetPropertyDefault("JOB_POOL_LINK", CM_NULLPTR); } } @@ -289,7 +293,7 @@ cmListFileBacktrace const* cmTarget::GetUtilityBacktrace( std::map<std::string, cmListFileBacktrace>::const_iterator i = this->UtilityBacktraces.find(u); if (i == this->UtilityBacktraces.end()) { - return 0; + return CM_NULLPTR; } return &i->second; @@ -405,7 +409,7 @@ cmSourceFile* cmTarget::AddSourceCMP0049(const std::string& s) { std::string src = this->ProcessSourceItemCMP0049(s); if (!s.empty() && src.empty()) { - return 0; + return CM_NULLPTR; } return this->AddSource(src); } @@ -476,7 +480,7 @@ cmSourceFile* cmTarget::AddSource(const std::string& src) this->Internal->SourceBacktraces.push_back(lfbt); } if (cmGeneratorExpression::Find(src) != std::string::npos) { - return 0; + return CM_NULLPTR; } return this->Makefile->GetOrCreateSource(src); } @@ -1060,7 +1064,7 @@ bool cmTarget::HandleLocationPropertyPolicy(cmMakefile* context) const return true; } std::ostringstream e; - const char* modal = 0; + const char* modal = CM_NULLPTR; cmake::MessageType messageType = cmake::AUTHOR_WARNING; switch (context->GetPolicyStatus(cmPolicies::CMP0026)) { case cmPolicies::WARN: @@ -1102,7 +1106,7 @@ const char* cmTarget::GetProperty(const std::string& prop, "The property \"" << prop << "\" is not allowed."; context->IssueMessage(cmake::FATAL_ERROR, e.str()); - return 0; + return CM_NULLPTR; } // Watch for special "computed" properties that are dependent on @@ -1115,7 +1119,7 @@ const char* cmTarget::GetProperty(const std::string& prop, static const std::string propLOCATION = "LOCATION"; if (prop == propLOCATION) { if (!this->HandleLocationPropertyPolicy(context)) { - return 0; + return CM_NULLPTR; } // Set the LOCATION property of the target. @@ -1144,7 +1148,7 @@ const char* cmTarget::GetProperty(const std::string& prop, // Support "LOCATION_<CONFIG>". else if (cmHasLiteralPrefix(prop, "LOCATION_")) { if (!this->HandleLocationPropertyPolicy(context)) { - return 0; + return CM_NULLPTR; } const char* configName = prop.c_str() + 9; @@ -1166,7 +1170,7 @@ const char* cmTarget::GetProperty(const std::string& prop, std::string configName(prop.c_str(), prop.size() - 9); if (configName != "IMPORTED") { if (!this->HandleLocationPropertyPolicy(context)) { - return 0; + return CM_NULLPTR; } if (this->IsImported()) { this->Properties.SetProperty( @@ -1213,7 +1217,7 @@ const char* cmTarget::GetProperty(const std::string& prop, if (specialProps.count(prop)) { if (prop == propLINK_LIBRARIES) { if (this->Internal->LinkImplementationPropertyEntries.empty()) { - return 0; + return CM_NULLPTR; } static std::string output; @@ -1225,7 +1229,7 @@ const char* cmTarget::GetProperty(const std::string& prop, return cmState::GetTargetTypeName(this->GetType()); } else if (prop == propINCLUDE_DIRECTORIES) { if (this->Internal->IncludeDirectoriesEntries.empty()) { - return 0; + return CM_NULLPTR; } static std::string output; @@ -1233,7 +1237,7 @@ const char* cmTarget::GetProperty(const std::string& prop, return output.c_str(); } else if (prop == propCOMPILE_FEATURES) { if (this->Internal->CompileFeaturesEntries.empty()) { - return 0; + return CM_NULLPTR; } static std::string output; @@ -1241,7 +1245,7 @@ const char* cmTarget::GetProperty(const std::string& prop, return output.c_str(); } else if (prop == propCOMPILE_OPTIONS) { if (this->Internal->CompileOptionsEntries.empty()) { - return 0; + return CM_NULLPTR; } static std::string output; @@ -1249,7 +1253,7 @@ const char* cmTarget::GetProperty(const std::string& prop, return output.c_str(); } else if (prop == propCOMPILE_DEFINITIONS) { if (this->Internal->CompileDefinitionsEntries.empty()) { - return 0; + return CM_NULLPTR; } static std::string output; @@ -1265,7 +1269,7 @@ const char* cmTarget::GetProperty(const std::string& prop, return this->GetMakefile()->GetCurrentSourceDirectory(); } else if (prop == propSOURCES) { if (this->Internal->SourceEntries.empty()) { - return 0; + return CM_NULLPTR; } std::ostringstream ss; @@ -1430,8 +1434,8 @@ std::string cmTarget::ImportedGetFullPath(const std::string& config, std::string result; - const char* loc = 0; - const char* imp = 0; + const char* loc = CM_NULLPTR; + const char* imp = CM_NULLPTR; std::string suffix; if (this->GetType() != cmState::INTERFACE_LIBRARY && diff --git a/Source/cmTarget.h b/Source/cmTarget.h index f91e5c6..209a729 100644 --- a/Source/cmTarget.h +++ b/Source/cmTarget.h @@ -19,9 +19,9 @@ #include "cmPolicies.h" #include "cmPropertyMap.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> #if defined(CMAKE_BUILD_WITH_CMAKE) -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP #include <unordered_map> #else #include <cmsys/hash_map.hxx> @@ -195,7 +195,7 @@ public: * name as would be specified to the ADD_EXECUTABLE or UTILITY_SOURCE * commands. It is not a full path nor does it have an extension. */ - void AddUtility(const std::string& u, cmMakefile* makefile = 0); + void AddUtility(const std::string& u, cmMakefile* makefile = CM_NULLPTR); ///! Get the utilities used by this target std::set<std::string> const& GetUtilities() const { return this->Utilities; } cmListFileBacktrace const* GetUtilityBacktrace(const std::string& u) const; @@ -331,7 +331,7 @@ private: }; #ifdef CMAKE_BUILD_WITH_CMAKE -#ifdef CMake_HAVE_CXX11_UNORDERED_MAP +#ifdef CMake_HAVE_CXX_UNORDERED_MAP typedef std::unordered_map<std::string, cmTarget> cmTargets; #else typedef cmsys::hash_map<std::string, cmTarget> cmTargets; diff --git a/Source/cmTargetCompileDefinitionsCommand.h b/Source/cmTargetCompileDefinitionsCommand.h index 29d86c5..1689a75 100644 --- a/Source/cmTargetCompileDefinitionsCommand.h +++ b/Source/cmTargetCompileDefinitionsCommand.h @@ -21,30 +21,36 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTargetCompileDefinitionsCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmTargetCompileDefinitionsCommand; + } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "target_compile_definitions"; } + std::string GetName() const CM_OVERRIDE + { + return "target_compile_definitions"; + } cmTypeMacro(cmTargetCompileDefinitionsCommand, cmTargetPropCommandBase); private: - virtual void HandleImportedTarget(const std::string& tgt); - virtual void HandleMissingTarget(const std::string& name); + void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE; + void HandleMissingTarget(const std::string& name) CM_OVERRIDE; - virtual bool HandleDirectContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); - virtual std::string Join(const std::vector<std::string>& content); + bool HandleDirectContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; + std::string Join(const std::vector<std::string>& content) CM_OVERRIDE; }; #endif diff --git a/Source/cmTargetCompileFeaturesCommand.h b/Source/cmTargetCompileFeaturesCommand.h index 3d883e9..4fae84a 100644 --- a/Source/cmTargetCompileFeaturesCommand.h +++ b/Source/cmTargetCompileFeaturesCommand.h @@ -16,23 +16,23 @@ class cmTargetCompileFeaturesCommand : public cmTargetPropCommandBase { - virtual cmCommand* Clone() { return new cmTargetCompileFeaturesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTargetCompileFeaturesCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; - virtual std::string GetName() const { return "target_compile_features"; } + std::string GetName() const CM_OVERRIDE { return "target_compile_features"; } cmTypeMacro(cmTargetCompileFeaturesCommand, cmTargetPropCommandBase); private: - virtual void HandleImportedTarget(const std::string& tgt); - virtual void HandleMissingTarget(const std::string& name); + void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE; + void HandleMissingTarget(const std::string& name) CM_OVERRIDE; - virtual bool HandleDirectContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); - virtual std::string Join(const std::vector<std::string>& content); + bool HandleDirectContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; + std::string Join(const std::vector<std::string>& content) CM_OVERRIDE; }; #endif diff --git a/Source/cmTargetCompileOptionsCommand.h b/Source/cmTargetCompileOptionsCommand.h index 231448b..7239629 100644 --- a/Source/cmTargetCompileOptionsCommand.h +++ b/Source/cmTargetCompileOptionsCommand.h @@ -21,30 +21,30 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTargetCompileOptionsCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTargetCompileOptionsCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "target_compile_options"; } + std::string GetName() const CM_OVERRIDE { return "target_compile_options"; } cmTypeMacro(cmTargetCompileOptionsCommand, cmTargetPropCommandBase); private: - virtual void HandleImportedTarget(const std::string& tgt); - virtual void HandleMissingTarget(const std::string& name); + void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE; + void HandleMissingTarget(const std::string& name) CM_OVERRIDE; - virtual bool HandleDirectContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); - virtual std::string Join(const std::vector<std::string>& content); + bool HandleDirectContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; + std::string Join(const std::vector<std::string>& content) CM_OVERRIDE; }; #endif diff --git a/Source/cmTargetIncludeDirectoriesCommand.h b/Source/cmTargetIncludeDirectoriesCommand.h index 4c907bd..ba5d980 100644 --- a/Source/cmTargetIncludeDirectoriesCommand.h +++ b/Source/cmTargetIncludeDirectoriesCommand.h @@ -21,34 +21,40 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTargetIncludeDirectoriesCommand; } + cmCommand* Clone() CM_OVERRIDE + { + return new cmTargetIncludeDirectoriesCommand; + } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "target_include_directories"; } + std::string GetName() const CM_OVERRIDE + { + return "target_include_directories"; + } cmTypeMacro(cmTargetIncludeDirectoriesCommand, cmTargetPropCommandBase); private: - virtual void HandleImportedTarget(const std::string& tgt); - virtual void HandleMissingTarget(const std::string& name); + void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE; + void HandleMissingTarget(const std::string& name) CM_OVERRIDE; - virtual bool HandleDirectContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); - virtual void HandleInterfaceContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); + bool HandleDirectContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; + void HandleInterfaceContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; - virtual std::string Join(const std::vector<std::string>& content); + std::string Join(const std::vector<std::string>& content) CM_OVERRIDE; }; #endif diff --git a/Source/cmTargetLinkLibrariesCommand.cxx b/Source/cmTargetLinkLibrariesCommand.cxx index 774577a..1c4a9ce 100644 --- a/Source/cmTargetLinkLibrariesCommand.cxx +++ b/Source/cmTargetLinkLibrariesCommand.cxx @@ -91,7 +91,7 @@ bool cmTargetLinkLibrariesCommand::InitialPass( if (this->Target->GetType() == cmState::UTILITY) { std::ostringstream e; - const char* modal = 0; + const char* modal = CM_NULLPTR; cmake::MessageType messageType = cmake::AUTHOR_WARNING; switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0039)) { case cmPolicies::WARN: @@ -307,7 +307,7 @@ bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib, if (!this->Target->PushTLLCommandTrace( sig, this->Makefile->GetExecutionContext())) { std::ostringstream e; - const char* modal = 0; + const char* modal = CM_NULLPTR; cmake::MessageType messageType = cmake::AUTHOR_WARNING; switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0023)) { case cmPolicies::WARN: diff --git a/Source/cmTargetLinkLibrariesCommand.h b/Source/cmTargetLinkLibrariesCommand.h index 016993d..4f58639 100644 --- a/Source/cmTargetLinkLibrariesCommand.h +++ b/Source/cmTargetLinkLibrariesCommand.h @@ -27,19 +27,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTargetLinkLibrariesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTargetLinkLibrariesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "target_link_libraries"; } + std::string GetName() const CM_OVERRIDE { return "target_link_libraries"; } cmTypeMacro(cmTargetLinkLibrariesCommand, cmCommand); diff --git a/Source/cmTargetSourcesCommand.h b/Source/cmTargetSourcesCommand.h index 304e176..9073204 100644 --- a/Source/cmTargetSourcesCommand.h +++ b/Source/cmTargetSourcesCommand.h @@ -21,31 +21,31 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTargetSourcesCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTargetSourcesCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "target_sources"; } + std::string GetName() const CM_OVERRIDE { return "target_sources"; } cmTypeMacro(cmTargetSourcesCommand, cmTargetPropCommandBase); private: - virtual void HandleImportedTarget(const std::string& tgt); - virtual void HandleMissingTarget(const std::string& name); + void HandleImportedTarget(const std::string& tgt) CM_OVERRIDE; + void HandleMissingTarget(const std::string& name) CM_OVERRIDE; - virtual bool HandleDirectContent(cmTarget* tgt, - const std::vector<std::string>& content, - bool prepend, bool system); + bool HandleDirectContent(cmTarget* tgt, + const std::vector<std::string>& content, + bool prepend, bool system) CM_OVERRIDE; - virtual std::string Join(const std::vector<std::string>& content); + std::string Join(const std::vector<std::string>& content) CM_OVERRIDE; }; #endif diff --git a/Source/cmTestGenerator.cxx b/Source/cmTestGenerator.cxx index e599825..462edf9 100644 --- a/Source/cmTestGenerator.cxx +++ b/Source/cmTestGenerator.cxx @@ -24,7 +24,7 @@ cmTestGenerator::cmTestGenerator( { this->ActionsPerConfig = !test->GetOldStyle(); this->TestGenerated = false; - this->LG = 0; + this->LG = CM_NULLPTR; } cmTestGenerator::~cmTestGenerator() @@ -83,7 +83,7 @@ void cmTestGenerator::GenerateScriptForConfig(std::ostream& os, // Prepend with the emulator when cross compiling if required. const char* emulator = target->GetProperty("CROSSCOMPILING_EMULATOR"); - if (emulator != 0) { + if (emulator != CM_NULLPTR) { std::vector<std::string> emulatorWithArgs; cmSystemTools::ExpandListArgument(emulator, emulatorWithArgs); std::string emulatorExe(emulatorWithArgs[0]); diff --git a/Source/cmTestGenerator.h b/Source/cmTestGenerator.h index f946a1c..66d590e 100644 --- a/Source/cmTestGenerator.h +++ b/Source/cmTestGenerator.h @@ -27,18 +27,20 @@ public: cmTestGenerator(cmTest* test, std::vector<std::string> const& configurations = std::vector<std::string>()); - virtual ~cmTestGenerator(); + ~cmTestGenerator() CM_OVERRIDE; void Compute(cmLocalGenerator* lg); protected: - virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent); - virtual void GenerateScriptActions(std::ostream& os, Indent const& indent); - virtual void GenerateScriptForConfig(std::ostream& os, - const std::string& config, - Indent const& indent); - virtual void GenerateScriptNoConfig(std::ostream& os, Indent const& indent); - virtual bool NeedsScriptNoConfig() const; + void GenerateScriptConfigs(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptActions(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptForConfig(std::ostream& os, const std::string& config, + Indent const& indent) CM_OVERRIDE; + void GenerateScriptNoConfig(std::ostream& os, + Indent const& indent) CM_OVERRIDE; + bool NeedsScriptNoConfig() const CM_OVERRIDE; void GenerateOldStyle(std::ostream& os, Indent const& indent); cmLocalGenerator* LG; diff --git a/Source/cmTimestamp.cxx b/Source/cmTimestamp.cxx index 2a70ed0..c3c1d17 100644 --- a/Source/cmTimestamp.cxx +++ b/Source/cmTimestamp.cxx @@ -22,7 +22,7 @@ std::string cmTimestamp::CurrentTime(const std::string& formatString, bool utcFlag) { - time_t currentTimeT = time(0); + time_t currentTimeT = time(CM_NULLPTR); if (currentTimeT == time_t(-1)) { return std::string(); } @@ -56,14 +56,14 @@ std::string cmTimestamp::CreateTimestampFromTimeT(time_t timeT, struct tm timeStruct; memset(&timeStruct, 0, sizeof(timeStruct)); - struct tm* ptr = (struct tm*)0; + struct tm* ptr = (struct tm*)CM_NULLPTR; if (utcFlag) { ptr = gmtime(&timeT); } else { ptr = localtime(&timeT); } - if (ptr == 0) { + if (ptr == CM_NULLPTR) { return std::string(); } diff --git a/Source/cmTryCompileCommand.h b/Source/cmTryCompileCommand.h index e50d54c..abfe335 100644 --- a/Source/cmTryCompileCommand.h +++ b/Source/cmTryCompileCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTryCompileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTryCompileCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "try_compile"; } + std::string GetName() const CM_OVERRIDE { return "try_compile"; } cmTypeMacro(cmTryCompileCommand, cmCoreTryCompile); }; diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx index 19837a7..7b19048 100644 --- a/Source/cmTryRunCommand.cxx +++ b/Source/cmTryRunCommand.cxx @@ -124,8 +124,9 @@ bool cmTryRunCommand::InitialPass(std::vector<std::string> const& argv, std::string runOutputContents; if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING") && !this->Makefile->IsDefinitionSet("CMAKE_CROSSCOMPILING_EMULATOR")) { - this->DoNotRunExecutable(runArgs, argv[3], - captureRunOutput ? &runOutputContents : 0); + this->DoNotRunExecutable(runArgs, argv[3], captureRunOutput + ? &runOutputContents + : CM_NULLPTR); } else { this->RunExecutable(runArgs, &runOutputContents); } @@ -186,9 +187,9 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs, finalCommand += runArgs; } int timeout = 0; - bool worked = - cmSystemTools::RunSingleCommand(finalCommand.c_str(), out, out, &retVal, 0, - cmSystemTools::OUTPUT_NONE, timeout); + bool worked = cmSystemTools::RunSingleCommand( + finalCommand.c_str(), out, out, &retVal, CM_NULLPTR, + cmSystemTools::OUTPUT_NONE, timeout); // set the run var char retChar[1000]; if (worked) { @@ -230,7 +231,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, this->RunResultVariable + "__TRYRUN_OUTPUT"; bool error = false; - if (this->Makefile->GetDefinition(this->RunResultVariable) == 0) { + if (this->Makefile->GetDefinition(this->RunResultVariable) == CM_NULLPTR) { // if the variables doesn't exist, create it with a helpful error text // and mark it as advanced std::string comment; @@ -252,8 +253,8 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, } // is the output from the executable used ? - if (out != 0) { - if (this->Makefile->GetDefinition(internalRunOutputName) == 0) { + if (out != CM_NULLPTR) { + if (this->Makefile->GetDefinition(internalRunOutputName) == CM_NULLPTR) { // if the variables doesn't exist, create it with a helpful error text // and mark it as advanced std::string comment; @@ -301,7 +302,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, comment += " to\n" " the exit code (in many cases 0 for success), otherwise " "enter \"FAILED_TO_RUN\".\n"; - if (out != 0) { + if (out != CM_NULLPTR) { comment += internalRunOutputName; comment += "\n contains the text the executable " @@ -332,7 +333,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, << this->Makefile->GetDefinition(this->RunResultVariable) << "\"\n CACHE STRING \"Result from TRY_RUN\" FORCE)\n\n"; - if (out != 0) { + if (out != CM_NULLPTR) { file << "set( " << internalRunOutputName << " \n \"" << this->Makefile->GetDefinition(internalRunOutputName) << "\"\n CACHE STRING \"Output from TRY_RUN\" FORCE)\n\n"; @@ -345,7 +346,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, "please set the following cache variables " "appropriately:\n"; errorMessage += " " + this->RunResultVariable + " (advanced)\n"; - if (out != 0) { + if (out != CM_NULLPTR) { errorMessage += " " + internalRunOutputName + " (advanced)\n"; } errorMessage += detailsString; @@ -353,7 +354,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs, return; } - if (out != 0) { + if (out != CM_NULLPTR) { (*out) = this->Makefile->GetDefinition(internalRunOutputName); } } diff --git a/Source/cmTryRunCommand.h b/Source/cmTryRunCommand.h index 26c0777..b8eb1de 100644 --- a/Source/cmTryRunCommand.h +++ b/Source/cmTryRunCommand.h @@ -25,19 +25,19 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmTryRunCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmTryRunCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "try_run"; } + std::string GetName() const CM_OVERRIDE { return "try_run"; } cmTypeMacro(cmTryRunCommand, cmCoreTryCompile); diff --git a/Source/cmTypeMacro.h b/Source/cmTypeMacro.h index 5c534c3..147eba8 100644 --- a/Source/cmTypeMacro.h +++ b/Source/cmTypeMacro.h @@ -15,7 +15,7 @@ // All subclasses of cmCommand or cmCTestGenericHandler should // invoke this macro. #define cmTypeMacro(thisClass, superclass) \ - virtual const char* GetNameOfClass() { return #thisClass; } \ + const char* GetNameOfClass() CM_OVERRIDE { return #thisClass; } \ typedef superclass Superclass; \ static bool IsTypeOf(const char* type) \ { \ @@ -24,7 +24,10 @@ } \ return Superclass::IsTypeOf(type); \ } \ - virtual bool IsA(const char* type) { return thisClass::IsTypeOf(type); } \ + bool IsA(const char* type) CM_OVERRIDE \ + { \ + return thisClass::IsTypeOf(type); \ + } \ static thisClass* SafeDownCast(cmObject* c) \ { \ if (c && c->IsA(#thisClass)) { \ diff --git a/Source/cmUnsetCommand.cxx b/Source/cmUnsetCommand.cxx index c04c44a..05ba65a 100644 --- a/Source/cmUnsetCommand.cxx +++ b/Source/cmUnsetCommand.cxx @@ -47,7 +47,7 @@ bool cmUnsetCommand::InitialPass(std::vector<std::string> const& args, } // unset(VAR PARENT_SCOPE) else if ((args.size() == 2) && (args[1] == "PARENT_SCOPE")) { - this->Makefile->RaiseScope(variable, 0); + this->Makefile->RaiseScope(variable, CM_NULLPTR); return true; } // ERROR: second argument isn't CACHE or PARENT_SCOPE diff --git a/Source/cmUnsetCommand.h b/Source/cmUnsetCommand.h index faa8f9b..6429c10 100644 --- a/Source/cmUnsetCommand.h +++ b/Source/cmUnsetCommand.h @@ -25,24 +25,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmUnsetCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmUnsetCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "unset"; } + std::string GetName() const CM_OVERRIDE { return "unset"; } cmTypeMacro(cmUnsetCommand, cmCommand); }; diff --git a/Source/cmUseMangledMesaCommand.h b/Source/cmUseMangledMesaCommand.h index 5a97a61..5a44035 100644 --- a/Source/cmUseMangledMesaCommand.h +++ b/Source/cmUseMangledMesaCommand.h @@ -18,11 +18,11 @@ class cmUseMangledMesaCommand : public cmCommand { public: cmTypeMacro(cmUseMangledMesaCommand, cmCommand); - virtual cmCommand* Clone() { return new cmUseMangledMesaCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "use_mangled_mesa"; } - virtual bool IsScriptable() const { return true; } + cmCommand* Clone() CM_OVERRIDE { return new cmUseMangledMesaCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "use_mangled_mesa"; } + bool IsScriptable() const CM_OVERRIDE { return true; } protected: void CopyAndFullPathMesaHeader(const char* source, const char* outdir); }; diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx index f7d766e..c50cbfb 100644 --- a/Source/cmUtilitySourceCommand.cxx +++ b/Source/cmUtilitySourceCommand.cxx @@ -38,7 +38,7 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args, bool haveCacheValue = false; if (this->Makefile->IsOn("CMAKE_CROSSCOMPILING")) { - haveCacheValue = (cacheValue != 0); + haveCacheValue = (cacheValue != CM_NULLPTR); if (!haveCacheValue) { std::string msg = "UTILITY_SOURCE is used in cross compiling mode for "; msg += cacheEntry; @@ -50,7 +50,7 @@ bool cmUtilitySourceCommand::InitialPass(std::vector<std::string> const& args, } else { cmState* state = this->Makefile->GetState(); haveCacheValue = - (cacheValue && (strstr(cacheValue, "(IntDir)") == 0 || + (cacheValue && (strstr(cacheValue, "(IntDir)") == CM_NULLPTR || (intDir && strcmp(intDir, "$(IntDir)") == 0)) && (state->GetCacheMajorVersion() != 0 && state->GetCacheMinorVersion() != 0)); diff --git a/Source/cmUtilitySourceCommand.h b/Source/cmUtilitySourceCommand.h index a709de1..2eb961f 100644 --- a/Source/cmUtilitySourceCommand.h +++ b/Source/cmUtilitySourceCommand.h @@ -18,10 +18,10 @@ class cmUtilitySourceCommand : public cmCommand { public: cmTypeMacro(cmUtilitySourceCommand, cmCommand); - virtual cmCommand* Clone() { return new cmUtilitySourceCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "utility_source"; } + cmCommand* Clone() CM_OVERRIDE { return new cmUtilitySourceCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "utility_source"; } }; #endif diff --git a/Source/cmVariableRequiresCommand.h b/Source/cmVariableRequiresCommand.h index b83f615..c4b0817 100644 --- a/Source/cmVariableRequiresCommand.h +++ b/Source/cmVariableRequiresCommand.h @@ -18,10 +18,10 @@ class cmVariableRequiresCommand : public cmCommand { public: cmTypeMacro(cmVariableRequiresCommand, cmCommand); - virtual cmCommand* Clone() { return new cmVariableRequiresCommand; } - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); - virtual std::string GetName() const { return "variable_requires"; } + cmCommand* Clone() CM_OVERRIDE { return new cmVariableRequiresCommand; } + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; + std::string GetName() const CM_OVERRIDE { return "variable_requires"; } }; #endif diff --git a/Source/cmVariableWatch.cxx b/Source/cmVariableWatch.cxx index 11eaa93..56e2770 100644 --- a/Source/cmVariableWatch.cxx +++ b/Source/cmVariableWatch.cxx @@ -13,7 +13,7 @@ #include "cmAlgorithms.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> static const char* const cmVariableWatchAccessStrings[] = { "READ_ACCESS", "UNKNOWN_READ_ACCESS", "UNKNOWN_DEFINED_ACCESS", @@ -48,7 +48,7 @@ bool cmVariableWatch::AddWatch(const std::string& variable, WatchMethod method, void* client_data /*=0*/, DeleteData delete_data /*=0*/) { - cmsys::auto_ptr<cmVariableWatch::Pair> p(new cmVariableWatch::Pair); + CM_AUTO_PTR<cmVariableWatch::Pair> p(new cmVariableWatch::Pair); p->Method = method; p->ClientData = client_data; p->DeleteDataCall = delete_data; diff --git a/Source/cmVariableWatch.h b/Source/cmVariableWatch.h index be8f72f..5ddb907 100644 --- a/Source/cmVariableWatch.h +++ b/Source/cmVariableWatch.h @@ -36,9 +36,10 @@ public: * Add watch to the variable */ bool AddWatch(const std::string& variable, WatchMethod method, - void* client_data = 0, DeleteData delete_data = 0); + void* client_data = CM_NULLPTR, + DeleteData delete_data = CM_NULLPTR); void RemoveWatch(const std::string& variable, WatchMethod method, - void* client_data = 0); + void* client_data = CM_NULLPTR); /** * This method is called when variable is accessed @@ -71,9 +72,9 @@ protected: void* ClientData; DeleteData DeleteDataCall; Pair() - : Method(0) - , ClientData(0) - , DeleteDataCall(0) + : Method(CM_NULLPTR) + , ClientData(CM_NULLPTR) + , DeleteDataCall(CM_NULLPTR) { } ~Pair() diff --git a/Source/cmVariableWatchCommand.h b/Source/cmVariableWatchCommand.h index aad53cb..1d402af 100644 --- a/Source/cmVariableWatchCommand.h +++ b/Source/cmVariableWatchCommand.h @@ -24,34 +24,34 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmVariableWatchCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmVariableWatchCommand; } //! Default constructor cmVariableWatchCommand(); //! Destructor. - ~cmVariableWatchCommand(); + ~cmVariableWatchCommand() CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** This command does not really have a final pass but it needs to stay alive since it owns variable watch callback information. */ - virtual bool HasFinalPass() const { return true; } + bool HasFinalPass() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "variable_watch"; } + std::string GetName() const CM_OVERRIDE { return "variable_watch"; } cmTypeMacro(cmVariableWatchCommand, cmCommand); diff --git a/Source/cmVisualStudio10TargetGenerator.cxx b/Source/cmVisualStudio10TargetGenerator.cxx index 635fad2..13e7c89 100644 --- a/Source/cmVisualStudio10TargetGenerator.cxx +++ b/Source/cmVisualStudio10TargetGenerator.cxx @@ -42,7 +42,7 @@ #include "cmVisualStudioGeneratorOptions.h" #include "windows.h" -#include <cmsys/auto_ptr.hxx> +#include <cm_auto_ptr.hxx> cmIDEFlagTable const* cmVisualStudio10TargetGenerator::GetClFlagTable() const { @@ -1229,8 +1229,7 @@ void cmVisualStudio10TargetGenerator::WriteExtraSource(cmSourceFile const* sf) if (!deployContent.empty()) { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = - ge.Parse(deployContent); + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(deployContent); // Deployment location cannot be set on a configuration basis if (!deployLocation.empty()) { this->WriteString("<Link>", 3); @@ -1684,7 +1683,7 @@ bool cmVisualStudio10TargetGenerator::ComputeClOptions( // copied from cmLocalVisualStudio7Generator.cxx 805 // TODO: Integrate code below with cmLocalVisualStudio7Generator. - cmsys::auto_ptr<Options> pOptions(new Options( + CM_AUTO_PTR<Options> pOptions(new Options( this->LocalGenerator, Options::Compiler, this->GetClFlagTable())); Options& clOptions = *pOptions; @@ -1848,7 +1847,7 @@ bool cmVisualStudio10TargetGenerator::ComputeRcOptions() bool cmVisualStudio10TargetGenerator::ComputeRcOptions( std::string const& configName) { - cmsys::auto_ptr<Options> pOptions(new Options( + CM_AUTO_PTR<Options> pOptions(new Options( this->LocalGenerator, Options::ResourceCompiler, this->GetRcFlagTable())); Options& rcOptions = *pOptions; @@ -1905,7 +1904,7 @@ bool cmVisualStudio10TargetGenerator::ComputeMasmOptions() bool cmVisualStudio10TargetGenerator::ComputeMasmOptions( std::string const& configName) { - cmsys::auto_ptr<Options> pOptions(new Options( + CM_AUTO_PTR<Options> pOptions(new Options( this->LocalGenerator, Options::MasmCompiler, this->GetMasmFlagTable())); Options& masmOptions = *pOptions; @@ -2058,7 +2057,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( if (const char* nativeLibDirectoriesExpression = this->GeneratorTarget->GetProperty("ANDROID_NATIVE_LIB_DIRECTORIES")) { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDirectoriesExpression); std::string nativeLibDirs = cge->Evaluate(this->LocalGenerator, configName); @@ -2071,7 +2070,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( this->GeneratorTarget->GetProperty( "ANDROID_NATIVE_LIB_DEPENDENCIES")) { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(nativeLibDependenciesExpression); std::string nativeLibDeps = cge->Evaluate(this->LocalGenerator, configName); @@ -2090,7 +2089,7 @@ void cmVisualStudio10TargetGenerator::WriteAntBuildOptions( if (const char* jarDirectoriesExpression = this->GeneratorTarget->GetProperty("ANDROID_JAR_DIRECTORIES")) { cmGeneratorExpression ge; - cmsys::auto_ptr<cmCompiledGeneratorExpression> cge = + CM_AUTO_PTR<cmCompiledGeneratorExpression> cge = ge.Parse(jarDirectoriesExpression); std::string jarDirectories = cge->Evaluate(this->LocalGenerator, configName); @@ -2150,7 +2149,7 @@ bool cmVisualStudio10TargetGenerator::ComputeLinkOptions() bool cmVisualStudio10TargetGenerator::ComputeLinkOptions( std::string const& config) { - cmsys::auto_ptr<Options> pOptions(new Options( + CM_AUTO_PTR<Options> pOptions(new Options( this->LocalGenerator, Options::Linker, this->GetLinkFlagTable(), 0, this)); Options& linkOptions = *pOptions; diff --git a/Source/cmWhileCommand.cxx b/Source/cmWhileCommand.cxx index bec2861..93a6271 100644 --- a/Source/cmWhileCommand.cxx +++ b/Source/cmWhileCommand.cxx @@ -37,8 +37,7 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff, // if this is the endwhile for this while loop then execute if (!this->Depth) { // Remove the function blocker for this scope or bail. - cmsys::auto_ptr<cmFunctionBlocker> fb( - mf.RemoveFunctionBlocker(this, lff)); + CM_AUTO_PTR<cmFunctionBlocker> fb(mf.RemoveFunctionBlocker(this, lff)); if (!fb.get()) { return false; } diff --git a/Source/cmWhileCommand.h b/Source/cmWhileCommand.h index 0f35be8..bd354c7 100644 --- a/Source/cmWhileCommand.h +++ b/Source/cmWhileCommand.h @@ -21,10 +21,10 @@ class cmWhileFunctionBlocker : public cmFunctionBlocker { public: cmWhileFunctionBlocker(cmMakefile* mf); - ~cmWhileFunctionBlocker(); - virtual bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, - cmExecutionStatus&); - virtual bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf); + ~cmWhileFunctionBlocker() CM_OVERRIDE; + bool IsFunctionBlocked(const cmListFileFunction& lff, cmMakefile& mf, + cmExecutionStatus&) CM_OVERRIDE; + bool ShouldRemove(const cmListFileFunction& lff, cmMakefile& mf) CM_OVERRIDE; std::vector<cmListFileArgument> Args; std::vector<cmListFileFunction> Functions; @@ -41,20 +41,21 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmWhileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmWhileCommand; } /** * This overrides the default InvokeInitialPass implementation. * It records the arguments before expansion. */ - virtual bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, - cmExecutionStatus&); + bool InvokeInitialPass(const std::vector<cmListFileArgument>& args, + cmExecutionStatus&) CM_OVERRIDE; /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const&, cmExecutionStatus&) + bool InitialPass(std::vector<std::string> const&, + cmExecutionStatus&) CM_OVERRIDE { return false; } @@ -62,12 +63,12 @@ public: /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "while"; } + std::string GetName() const CM_OVERRIDE { return "while"; } cmTypeMacro(cmWhileCommand, cmCommand); }; diff --git a/Source/cmWriteFileCommand.h b/Source/cmWriteFileCommand.h index b0eef9c..db24b0e 100644 --- a/Source/cmWriteFileCommand.h +++ b/Source/cmWriteFileCommand.h @@ -24,24 +24,24 @@ public: /** * This is a virtual constructor for the command. */ - virtual cmCommand* Clone() { return new cmWriteFileCommand; } + cmCommand* Clone() CM_OVERRIDE { return new cmWriteFileCommand; } /** * This is called when the command is first encountered in * the CMakeLists.txt file. */ - virtual bool InitialPass(std::vector<std::string> const& args, - cmExecutionStatus& status); + bool InitialPass(std::vector<std::string> const& args, + cmExecutionStatus& status) CM_OVERRIDE; /** * This determines if the command is invoked when in script mode. */ - virtual bool IsScriptable() const { return true; } + bool IsScriptable() const CM_OVERRIDE { return true; } /** * The name of the command as specified in CMakeList.txt. */ - virtual std::string GetName() const { return "write_file"; } + std::string GetName() const CM_OVERRIDE { return "write_file"; } cmTypeMacro(cmWriteFileCommand, cmCommand); }; diff --git a/Source/kwsys/auto_ptr.hxx.in b/Source/cm_auto_ptr.hxx index ad9654c..2cd35c3 100644 --- a/Source/kwsys/auto_ptr.hxx.in +++ b/Source/cm_auto_ptr.hxx @@ -1,6 +1,6 @@ /*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium + CMake - Cross Platform Makefile Generator + Copyright 2000-2016 Kitware, Inc. Distributed under the OSI-approved BSD License (the "License"); see accompanying file Copyright.txt for details. @@ -9,26 +9,29 @@ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more information. ============================================================================*/ -#ifndef @KWSYS_NAMESPACE@_auto_ptr_hxx -#define @KWSYS_NAMESPACE@_auto_ptr_hxx +#ifndef CM_AUTO_PTR_HXX +#define CM_AUTO_PTR_HXX -#include <@KWSYS_NAMESPACE@/Configure.hxx> +#include <cmsys/Configure.hxx> -// The HP compiler and VS6 cannot handle the conversions necessary to use +// FIXME: Use std::auto_ptr on compilers that do not warn about it. +#define CM_AUTO_PTR cm::auto_ptr + +// The HP compiler cannot handle the conversions necessary to use // auto_ptr_ref to pass an auto_ptr returned from one function // directly to another function as in use_auto_ptr(get_auto_ptr()). // We instead use const_cast to achieve the syntax on those platforms. // We do not use const_cast on other platforms to maintain the C++ // standard design and guarantee that if an auto_ptr is bound // to a reference-to-const then ownership will be maintained. -#if defined(__HP_aCC) || (defined(_MSC_VER) && _MSC_VER <= 1200) -# define @KWSYS_NAMESPACE@_AUTO_PTR_REF 0 -# define @KWSYS_NAMESPACE@_AUTO_PTR_CONST const -# define @KWSYS_NAMESPACE@_AUTO_PTR_CAST(a) cast(a) +#if defined(__HP_aCC) +#define cm_AUTO_PTR_REF 0 +#define cm_AUTO_PTR_CONST const +#define cm_AUTO_PTR_CAST(a) cast(a) #else -# define @KWSYS_NAMESPACE@_AUTO_PTR_REF 1 -# define @KWSYS_NAMESPACE@_AUTO_PTR_CONST -# define @KWSYS_NAMESPACE@_AUTO_PTR_CAST(a) a +#define cm_AUTO_PTR_REF 1 +#define cm_AUTO_PTR_CONST +#define cm_AUTO_PTR_CAST(a) a #endif // In C++11, clang will warn about using dynamic exception specifications @@ -36,24 +39,24 @@ // mimic std::auto_ptr, we want to keep the 'throw()' decorations below. // So we suppress the warning. #if defined(__clang__) && defined(__has_warning) -# if __has_warning("-Wdeprecated") -# pragma clang diagnostic push -# pragma clang diagnostic ignored "-Wdeprecated" -# endif +#if __has_warning("-Wdeprecated") +#pragma clang diagnostic push +#pragma clang diagnostic ignored "-Wdeprecated" +#endif #endif -namespace @KWSYS_NAMESPACE@ -{ +namespace cm { -template <class X> class auto_ptr; +template <class X> +class auto_ptr; -#if @KWSYS_NAMESPACE@_AUTO_PTR_REF -namespace detail -{ +#if cm_AUTO_PTR_REF +namespace detail { // The auto_ptr_ref template is supposed to be a private member of // auto_ptr but Borland 5.8 cannot handle it. Instead put it in // a private namespace. -template <class Y> struct auto_ptr_ref +template <class Y> +struct auto_ptr_ref { Y* p_; @@ -62,7 +65,10 @@ template <class Y> struct auto_ptr_ref // this should be done with the explicit keyword but Borland 5.x // generates code in the conversion operator to call itself // infinately. - auto_ptr_ref(Y* p, int): p_(p) {} + auto_ptr_ref(Y* p, int) + : p_(p) + { + } }; } #endif @@ -71,10 +77,12 @@ template <class Y> struct auto_ptr_ref template <class X> class auto_ptr { -#if !@KWSYS_NAMESPACE@_AUTO_PTR_REF +#if !cm_AUTO_PTR_REF template <typename Y> static inline auto_ptr<Y>& cast(auto_ptr<Y> const& a) - { return const_cast<auto_ptr<Y>&>(a); } + { + return const_cast<auto_ptr<Y>&>(a); + } #endif /** The pointer to the object held. */ @@ -87,19 +95,19 @@ public: /** Construct from an auto_ptr holding a compatible object. This transfers ownership to the newly constructed auto_ptr. */ template <class Y> - auto_ptr(auto_ptr<Y> @KWSYS_NAMESPACE@_AUTO_PTR_CONST& a) throw(): - x_(@KWSYS_NAMESPACE@_AUTO_PTR_CAST(a).release()) - { - } + auto_ptr(auto_ptr<Y> cm_AUTO_PTR_CONST& a) throw() + : x_(cm_AUTO_PTR_CAST(a).release()) + { + } /** Assign from an auto_ptr holding a compatible object. This transfers ownership to the left-hand-side of the assignment. */ template <class Y> - auto_ptr& operator=(auto_ptr<Y> @KWSYS_NAMESPACE@_AUTO_PTR_CONST& a) throw() - { - this->reset(@KWSYS_NAMESPACE@_AUTO_PTR_CAST(a).release()); + auto_ptr& operator=(auto_ptr<Y> cm_AUTO_PTR_CONST& a) throw() + { + this->reset(cm_AUTO_PTR_CAST(a).release()); return *this; - } + } /** * Explicitly construct from a raw pointer. This is typically @@ -107,113 +115,107 @@ public: * * auto_ptr<X> ptr(new X()); */ - explicit auto_ptr(X* p=0) throw(): x_(p) - { - } + explicit auto_ptr(X* p = 0) throw() + : x_(p) + { + } /** Construct from another auto_ptr holding an object of the same type. This transfers ownership to the newly constructed auto_ptr. */ - auto_ptr(auto_ptr @KWSYS_NAMESPACE@_AUTO_PTR_CONST& a) throw(): - x_(@KWSYS_NAMESPACE@_AUTO_PTR_CAST(a).release()) - { - } + auto_ptr(auto_ptr cm_AUTO_PTR_CONST& a) throw() + : x_(cm_AUTO_PTR_CAST(a).release()) + { + } /** Assign from another auto_ptr holding an object of the same type. This transfers ownership to the newly constructed auto_ptr. */ - auto_ptr& operator=(auto_ptr @KWSYS_NAMESPACE@_AUTO_PTR_CONST& a) throw() - { - this->reset(@KWSYS_NAMESPACE@_AUTO_PTR_CAST(a).release()); + auto_ptr& operator=(auto_ptr cm_AUTO_PTR_CONST& a) throw() + { + this->reset(cm_AUTO_PTR_CAST(a).release()); return *this; - } + } /** Destruct and delete the object held. */ ~auto_ptr() throw() - { + { // Assume object destructor is nothrow. delete this->x_; - } + } /** Dereference and return a reference to the object held. */ - X& operator*() const throw() - { - return *this->x_; - } + X& operator*() const throw() { return *this->x_; } /** Return a pointer to the object held. */ - X* operator->() const throw() - { - return this->x_; - } + X* operator->() const throw() { return this->x_; } /** Return a pointer to the object held. */ - X* get() const throw() - { - return this->x_; - } + X* get() const throw() { return this->x_; } /** Return a pointer to the object held and reset to hold no object. This transfers ownership to the caller. */ X* release() throw() - { + { X* x = this->x_; this->x_ = 0; return x; - } + } /** Assume ownership of the given object. The object previously held is deleted. */ - void reset(X* p=0) throw() - { - if(this->x_ != p) - { + void reset(X* p = 0) throw() + { + if (this->x_ != p) { // Assume object destructor is nothrow. delete this->x_; this->x_ = p; - } } + } /** Convert to an auto_ptr holding an object of a compatible type. This transfers ownership to the returned auto_ptr. */ - template <class Y> operator auto_ptr<Y>() throw() - { + template <class Y> + operator auto_ptr<Y>() throw() + { return auto_ptr<Y>(this->release()); - } + } -#if @KWSYS_NAMESPACE@_AUTO_PTR_REF +#if cm_AUTO_PTR_REF /** Construct from an auto_ptr_ref. This is used when the constructor argument is a call to a function returning an auto_ptr. */ - auto_ptr(detail::auto_ptr_ref<X> r) throw(): x_(r.p_) - { - } + auto_ptr(detail::auto_ptr_ref<X> r) throw() + : x_(r.p_) + { + } /** Assign from an auto_ptr_ref. This is used when a function returning an auto_ptr is passed on the right-hand-side of an assignment. */ auto_ptr& operator=(detail::auto_ptr_ref<X> r) throw() - { + { this->reset(r.p_); return *this; - } + } /** Convert to an auto_ptr_ref. This is used when a function returning an auto_ptr is the argument to the constructor of another auto_ptr. */ - template <class Y> operator detail::auto_ptr_ref<Y>() throw() - { + template <class Y> + operator detail::auto_ptr_ref<Y>() throw() + { return detail::auto_ptr_ref<Y>(this->release(), 1); - } + } #endif }; -} // namespace @KWSYS_NAMESPACE@ +} // namespace cm // Undo warning suppression. #if defined(__clang__) && defined(__has_warning) -# if __has_warning("-Wdeprecated") -# pragma clang diagnostic pop -# endif +#if __has_warning("-Wdeprecated") +#pragma clang diagnostic pop +#endif #endif #endif diff --git a/Source/cmake.cxx b/Source/cmake.cxx index 654100b..c597605 100644 --- a/Source/cmake.cxx +++ b/Source/cmake.cxx @@ -145,9 +145,9 @@ cmake::cmake() } #endif - this->GlobalGenerator = 0; - this->ProgressCallback = 0; - this->ProgressCallbackClientData = 0; + this->GlobalGenerator = CM_NULLPTR; + this->ProgressCallback = CM_NULLPTR; + this->ProgressCallbackClientData = CM_NULLPTR; this->CurrentWorkingMode = NORMAL_MODE; #ifdef CMAKE_BUILD_WITH_CMAKE @@ -191,7 +191,7 @@ cmake::~cmake() delete this->State; if (this->GlobalGenerator) { delete this->GlobalGenerator; - this->GlobalGenerator = 0; + this->GlobalGenerator = CM_NULLPTR; } cmDeleteAll(this->Generators); #ifdef CMAKE_BUILD_WITH_CMAKE @@ -397,7 +397,7 @@ void cmake::ReadListFile(const std::vector<std::string>& args, snapshot.GetDirectory().SetCurrentSource( cmSystemTools::GetCurrentWorkingDirectory()); snapshot.SetDefaultDefinitions(); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(gg, snapshot)); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(gg, snapshot)); if (this->GetWorkingMode() != NORMAL_MODE) { std::string file(cmSystemTools::CollapseFullPath(path)); cmSystemTools::ConvertToUnixSlashes(file); @@ -463,7 +463,8 @@ bool cmake::FindPackage(const std::vector<std::string>& args) gg->CreateGenerationObjects(); cmLocalGenerator* lg = gg->LocalGenerators[0]; - std::string includeFlags = lg->GetIncludeFlags(includeDirs, 0, language); + std::string includeFlags = + lg->GetIncludeFlags(includeDirs, CM_NULLPTR, language); std::string definitions = mf->GetSafeDefinition("PACKAGE_DEFINITIONS"); printf("%s %s\n", includeFlags.c_str(), definitions.c_str()); @@ -870,7 +871,7 @@ void cmake::GetRegisteredGenerators(std::vector<GeneratorInfo>& generators) cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname) { - cmExternalMakefileProjectGenerator* extraGenerator = 0; + cmExternalMakefileProjectGenerator* extraGenerator = CM_NULLPTR; std::string name = gname; RegisteredExtraGeneratorsMap::const_iterator extraGenIt = this->ExtraGenerators.find(name); @@ -879,7 +880,7 @@ cmGlobalGenerator* cmake::CreateGlobalGenerator(const std::string& gname) name = extraGenerator->GetGlobalGeneratorName(name); } - cmGlobalGenerator* generator = 0; + cmGlobalGenerator* generator = CM_NULLPTR; for (RegisteredGeneratorsVector::const_iterator i = this->Generators.begin(); i != this->Generators.end(); ++i) { generator = (*i)->CreateGlobalGenerator(name, this); @@ -1707,8 +1708,8 @@ int cmake::CheckBuildSystem() // the make system's VERBOSE environment variable to enable verbose // output. This can be skipped by setting CMAKE_NO_VERBOSE (which is set // by the Eclipse and KDevelop generators). - bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0) && - (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0)); + bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR) && + (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == CM_NULLPTR)); // This method will check the integrity of the build system if the // option was given on the command line. It reads the given file to @@ -1742,7 +1743,7 @@ int cmake::CheckBuildSystem() cm.SetHomeOutputDirectory(""); cm.GetCurrentSnapshot().SetDefaultDefinitions(); cmGlobalGenerator gg(&cm); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(&gg, cm.GetCurrentSnapshot())); if (!mf->ReadListFile(this->CheckBuildSystemArgument.c_str()) || cmSystemTools::GetErrorOccuredFlag()) { if (verbose) { @@ -1763,14 +1764,12 @@ int cmake::CheckBuildSystem() } // Create the generator and use it to clear the dependencies. - cmsys::auto_ptr<cmGlobalGenerator> ggd( - this->CreateGlobalGenerator(genName)); + CM_AUTO_PTR<cmGlobalGenerator> ggd(this->CreateGlobalGenerator(genName)); if (ggd.get()) { cm.GetCurrentSnapshot().SetDefaultDefinitions(); - cmsys::auto_ptr<cmMakefile> mfd( + CM_AUTO_PTR<cmMakefile> mfd( new cmMakefile(ggd.get(), cm.GetCurrentSnapshot())); - cmsys::auto_ptr<cmLocalGenerator> lgd( - ggd->CreateLocalGenerator(mfd.get())); + CM_AUTO_PTR<cmLocalGenerator> lgd(ggd->CreateLocalGenerator(mfd.get())); lgd->ClearDependencies(mfd.get(), verbose); } } @@ -1910,7 +1909,7 @@ void cmake::MarkCliAsUsed(const std::string& variable) void cmake::GenerateGraphViz(const char* fileName) const { #ifdef CMAKE_BUILD_WITH_CMAKE - cmsys::auto_ptr<cmGraphVizWriter> gvWriter( + CM_AUTO_PTR<cmGraphVizWriter> gvWriter( new cmGraphVizWriter(this->GetGlobalGenerator()->GetLocalGenerators())); std::string settingsFile = this->GetHomeOutputDirectory(); @@ -1973,7 +1972,7 @@ cmInstalledFile const* cmake::GetInstalledFile(const std::string& name) const cmInstalledFile const& file = i->second; return &file; } else { - return 0; + return CM_NULLPTR; } } @@ -2391,7 +2390,7 @@ int cmake::Build(const std::string& dir, const std::string& target, std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n"; return 1; } - cmsys::auto_ptr<cmGlobalGenerator> gen( + CM_AUTO_PTR<cmGlobalGenerator> gen( this->CreateGlobalGenerator(cachedGenerator)); if (!gen.get()) { std::cerr << "Error: could create CMAKE_GENERATOR \"" << cachedGenerator diff --git a/Source/cmake.h b/Source/cmake.h index 9ac6935..4a5376d 100644 --- a/Source/cmake.h +++ b/Source/cmake.h @@ -250,7 +250,8 @@ public: * number provided may be negative in cases where a message is * to be displayed without any progress percentage. */ - void SetProgressCallback(ProgressCallbackType f, void* clientData = 0); + void SetProgressCallback(ProgressCallbackType f, + void* clientData = CM_NULLPTR); ///! this is called by generators to update the progress void UpdateProgress(const char* msg, float prog); diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx index 495aae5..521a5bf 100644 --- a/Source/cmakemain.cxx +++ b/Source/cmakemain.cxx @@ -29,22 +29,23 @@ #ifdef CMAKE_BUILD_WITH_CMAKE static const char* cmDocumentationName[][2] = { - { 0, " cmake - Cross-Platform Makefile Generator." }, - { 0, 0 } + { CM_NULLPTR, " cmake - Cross-Platform Makefile Generator." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationUsage[][2] = { - { 0, " cmake [options] <path-to-source>\n" - " cmake [options] <path-to-existing-build>" }, - { 0, "Specify a source directory to (re-)generate a build system for " - "it in the current working directory. Specify an existing build " - "directory to re-generate its build system." }, - { 0, 0 } + { CM_NULLPTR, " cmake [options] <path-to-source>\n" + " cmake [options] <path-to-existing-build>" }, + { CM_NULLPTR, + "Specify a source directory to (re-)generate a build system for " + "it in the current working directory. Specify an existing build " + "directory to re-generate its build system." }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationUsageNote[][2] = { - { 0, "Run 'cmake --help' for more information." }, - { 0, 0 } + { CM_NULLPTR, "Run 'cmake --help' for more information." }, + { CM_NULLPTR, CM_NULLPTR } }; #define CMAKE_BUILD_OPTIONS \ @@ -80,7 +81,7 @@ static const char* cmDocumentationOptions[][2] = { { "--no-warn-unused-cli", "Don't warn about command line options." }, { "--check-system-vars", "Find problems with variable usage in system " "files." }, - { 0, 0 } + { CM_NULLPTR, CM_NULLPTR } }; #endif @@ -106,7 +107,7 @@ static cmMakefile* cmakemainGetMakefile(void* clientdata) return gg->GetCurrentMakefile(); } } - return 0; + return CM_NULLPTR; } static std::string cmakemainGetStack(void* clientdata) diff --git a/Source/cmcmd.cxx b/Source/cmcmd.cxx index 161256e..010a3b2 100644 --- a/Source/cmcmd.cxx +++ b/Source/cmcmd.cxx @@ -315,7 +315,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Run the iwyu command line. Capture its stderr and hide its stdout. std::string stdErr; - if (!cmSystemTools::RunSingleCommand(iwyu_cmd, 0, &stdErr, &ret, 0, + if (!cmSystemTools::RunSingleCommand(iwyu_cmd, CM_NULLPTR, &stdErr, + &ret, CM_NULLPTR, cmSystemTools::OUTPUT_NONE)) { std::cerr << "Error running '" << iwyu_cmd[0] << "': " << stdErr << "\n"; @@ -343,7 +344,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Run the tidy command line. Capture its stdout and hide its stderr. std::string stdOut; - if (!cmSystemTools::RunSingleCommand(tidy_cmd, &stdOut, 0, &ret, 0, + if (!cmSystemTools::RunSingleCommand(tidy_cmd, &stdOut, CM_NULLPTR, + &ret, CM_NULLPTR, cmSystemTools::OUTPUT_NONE)) { std::cerr << "Error running '" << tidy_cmd[0] << "'\n"; return 1; @@ -363,7 +365,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Run the ldd -u -r command line. // Capture its stdout and hide its stderr. std::string stdOut; - if (!cmSystemTools::RunSingleCommand(lwyu_cmd, &stdOut, 0, &ret, 0, + if (!cmSystemTools::RunSingleCommand(lwyu_cmd, &stdOut, CM_NULLPTR, + &ret, CM_NULLPTR, cmSystemTools::OUTPUT_NONE)) { std::cerr << "Error running '" << lwyu_cmd[0] << "'\n"; return 1; @@ -379,7 +382,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Now run the real compiler command and return its result value. if (lwyu.empty() && !cmSystemTools::RunSingleCommand( - orig_cmd, 0, 0, &ret, 0, cmSystemTools::OUTPUT_PASSTHROUGH)) { + orig_cmd, CM_NULLPTR, CM_NULLPTR, &ret, CM_NULLPTR, + cmSystemTools::OUTPUT_PASSTHROUGH)) { std::cerr << "Error running '" << orig_cmd[0] << "'\n"; return 1; } @@ -429,7 +433,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Execute command from remaining arguments. std::vector<std::string> cmd(ai, ae); int retval; - if (cmSystemTools::RunSingleCommand(cmd, 0, 0, &retval, NULL, + if (cmSystemTools::RunSingleCommand(cmd, CM_NULLPTR, CM_NULLPTR, &retval, + CM_NULLPTR, cmSystemTools::OUTPUT_PASSTHROUGH)) { return retval; } @@ -537,7 +542,7 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) time(&time_start); clock_start = clock(); int ret = 0; - cmSystemTools::RunSingleCommand(command, 0, 0, &ret); + cmSystemTools::RunSingleCommand(command, CM_NULLPTR, CM_NULLPTR, &ret); clock_finish = clock(); time(&time_finish); @@ -588,8 +593,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) int retval = 0; int timeout = 0; if (cmSystemTools::RunSingleCommand( - command.c_str(), 0, 0, &retval, directory.c_str(), - cmSystemTools::OUTPUT_PASSTHROUGH, timeout)) { + command.c_str(), CM_NULLPTR, CM_NULLPTR, &retval, + directory.c_str(), cmSystemTools::OUTPUT_PASSTHROUGH, timeout)) { return retval; } @@ -695,8 +700,9 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) // Use the make system's VERBOSE environment variable to enable // verbose output. This can be skipped by also setting CMAKE_NO_VERBOSE // (which is set by the Eclipse and KDevelop generators). - bool verbose = ((cmSystemTools::GetEnv("VERBOSE") != 0) && - (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == 0)); + bool verbose = + ((cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR) && + (cmSystemTools::GetEnv("CMAKE_NO_VERBOSE") == CM_NULLPTR)); // Create a cmake object instance to process dependencies. cmake cm; @@ -759,9 +765,8 @@ int cmcmd::ExecuteCMakeCommand(std::vector<std::string>& args) cmState::Snapshot snapshot = cm.GetCurrentSnapshot(); snapshot.GetDirectory().SetCurrentBinary(startOutDir); snapshot.GetDirectory().SetCurrentSource(startDir); - cmsys::auto_ptr<cmMakefile> mf(new cmMakefile(ggd, snapshot)); - cmsys::auto_ptr<cmLocalGenerator> lgd( - ggd->CreateLocalGenerator(mf.get())); + CM_AUTO_PTR<cmMakefile> mf(new cmMakefile(ggd, snapshot)); + CM_AUTO_PTR<cmLocalGenerator> lgd(ggd->CreateLocalGenerator(mf.get())); // Actually scan dependencies. return lgd->UpdateDependencies(depInfo.c_str(), verbose, color) ? 0 @@ -1146,7 +1151,7 @@ int cmcmd::ExecuteLinkScript(std::vector<std::string>& args) } // Setup this command line. - const char* cmd[2] = { command.c_str(), 0 }; + const char* cmd[2] = { command.c_str(), CM_NULLPTR }; cmsysProcess_SetCommand(cp, cmd); // Report the command if verbose output is enabled. @@ -1156,7 +1161,7 @@ int cmcmd::ExecuteLinkScript(std::vector<std::string>& args) // Run the command and wait for it to exit. cmsysProcess_Execute(cp); - cmsysProcess_WaitForExit(cp, 0); + cmsysProcess_WaitForExit(cp, CM_NULLPTR); // Report failure if any. switch (cmsysProcess_GetState(cp)) { @@ -1249,7 +1254,7 @@ int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type) if (args.size() < 2) { return -1; } - bool verbose = cmSystemTools::GetEnv("VERBOSE") != NULL; + bool verbose = cmSystemTools::GetEnv("VERBOSE") != CM_NULLPTR; std::vector<std::string> expandedArgs; for (std::vector<std::string>::iterator i = args.begin(); i != args.end(); ++i) { @@ -1273,7 +1278,7 @@ int cmcmd::VisualStudioLink(std::vector<std::string>& args, int type) } static bool RunCommand(const char* comment, std::vector<std::string>& command, - bool verbose, int* retCodeOut = 0) + bool verbose, int* retCodeOut = CM_NULLPTR) { if (verbose) { std::cout << comment << ":\n"; @@ -1282,8 +1287,9 @@ static bool RunCommand(const char* comment, std::vector<std::string>& command, std::string output; int retCode = 0; // use rc command to create .res file - bool res = cmSystemTools::RunSingleCommand( - command, &output, &output, &retCode, 0, cmSystemTools::OUTPUT_NONE); + bool res = + cmSystemTools::RunSingleCommand(command, &output, &output, &retCode, + CM_NULLPTR, cmSystemTools::OUTPUT_NONE); // always print the output of the command, unless // it is the dumb rc command banner, but if the command // returned an error code then print the output anyway as diff --git a/Source/ctest.cxx b/Source/ctest.cxx index 4edd62e..38ff64f 100644 --- a/Source/ctest.cxx +++ b/Source/ctest.cxx @@ -21,12 +21,13 @@ #include "cmsys/Encoding.hxx" static const char* cmDocumentationName[][2] = { - { 0, " ctest - Testing driver provided by CMake." }, - { 0, 0 } + { CM_NULLPTR, " ctest - Testing driver provided by CMake." }, + { CM_NULLPTR, CM_NULLPTR } }; -static const char* cmDocumentationUsage[][2] = { { 0, " ctest [options]" }, - { 0, 0 } }; +static const char* cmDocumentationUsage[][2] = { { CM_NULLPTR, + " ctest [options]" }, + { CM_NULLPTR, CM_NULLPTR } }; static const char* cmDocumentationOptions[][2] = { { "-C <cfg>, --build-config <cfg>", "Choose configuration to test." }, @@ -108,7 +109,7 @@ static const char* cmDocumentationOptions[][2] = { { "--http1.0", "Submit using HTTP 1.0." }, { "--no-compress-output", "Do not compress test output when submitting." }, { "--print-labels", "Print all available test labels." }, - { 0, 0 } + { CM_NULLPTR, CM_NULLPTR } }; // this is a test driver program for cmCTest. diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt index 8b15394..39b03b3 100644 --- a/Source/kwsys/CMakeLists.txt +++ b/Source/kwsys/CMakeLists.txt @@ -663,7 +663,6 @@ SET(KWSYS_CLASSES) SET(KWSYS_H_FILES Configure SharedForward) SET(KWSYS_HXX_FILES Configure String hashtable hash_fun hash_map hash_set - auto_ptr ) # Add selected C++ classes. @@ -903,7 +902,6 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR) # C++ tests IF(NOT WATCOM) SET(KWSYS_CXX_TESTS - testAutoPtr testHashSTL ) ENDIF() diff --git a/Source/kwsys/testAutoPtr.cxx b/Source/kwsys/testAutoPtr.cxx deleted file mode 100644 index ed75ff4..0000000 --- a/Source/kwsys/testAutoPtr.cxx +++ /dev/null @@ -1,166 +0,0 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ -#ifdef __BORLANDC__ -# pragma warn -8027 /* 'for' not inlined. */ -# pragma warn -8026 /* exception not inlined. */ -#endif -#include "kwsysPrivate.h" -#include KWSYS_HEADER(auto_ptr.hxx) -// Work-around CMake dependency scanning limitation. This must -// duplicate the above list of headers. -#if 0 -# include "auto_ptr.hxx.in" -#endif - -#include <stdio.h> - -#define ASSERT(x,y) if (!(x)) { printf("FAIL: " y "\n"); status = 1; } - -int instances = 0; // don't declare as static - -struct A -{ - A() { ++instances; } - ~A() { --instances; } - A* self() {return this; } -}; -struct B: public A {}; - -static int function_call(kwsys::auto_ptr<A> a) -{ - return a.get()? 1:0; -} - -static A* get_A(A& a) { return &a; } - -static kwsys::auto_ptr<A> generate_auto_ptr_A() -{ - return kwsys::auto_ptr<A>(new A); -} - -static kwsys::auto_ptr<B> generate_auto_ptr_B() -{ - return kwsys::auto_ptr<B>(new B); -} - -int testAutoPtr(int, char*[]) -{ - int status = 0; - - // Keep everything in a subscope so we can detect leaks. - { - kwsys::auto_ptr<A> pa0; - kwsys::auto_ptr<A> pa1(new A()); - kwsys::auto_ptr<B> pb1(new B()); - kwsys::auto_ptr<B> pb2(new B()); - kwsys::auto_ptr<A> pa2(new B()); - - A* ptr = get_A(*pa1); - ASSERT(ptr == pa1.get(), - "auto_ptr does not return correct object when dereferenced"); - ptr = pa1->self(); - ASSERT(ptr == pa1.get(), - "auto_ptr does not return correct pointer from operator->"); - - A* before = pa0.get(); - pa0.reset(new A()); - ASSERT(pa0.get() && pa0.get() != before, - "auto_ptr empty after reset(new A())"); - - before = pa0.get(); - pa0.reset(new B()); - ASSERT(pa0.get() && pa0.get() != before, - "auto_ptr empty after reset(new B())"); - - delete pa0.release(); - ASSERT(!pa0.get(), "auto_ptr holds an object after release()"); - - kwsys::auto_ptr<A> pa3(pb1); - ASSERT(!pb1.get(), - "auto_ptr full after being used to construct another"); - ASSERT(pa3.get(), - "auto_ptr empty after construction from another"); - - { - kwsys::auto_ptr<A> pa; - pa = pa3; - ASSERT(!pa3.get(), - "auto_ptr full after assignment to another"); - ASSERT(pa.get(), - "auto_ptr empty after assignment from another"); - } - - { - kwsys::auto_ptr<A> pa; - pa = pb2; - ASSERT(!pb2.get(), - "auto_ptr full after assignment to compatible"); - ASSERT(pa.get(), - "auto_ptr empty after assignment from compatible"); - } - - { - int receive = function_call(pa2); - ASSERT(receive, - "auto_ptr did not receive ownership in called function"); - ASSERT(!pa2.get(), - "auto_ptr did not release ownership to called function"); - } - - { - int received = function_call(generate_auto_ptr_A()); - ASSERT(received, - "auto_ptr in called function did not take ownership " - "from factory function"); - } - -#if 0 - // Is this allowed by the standard? - { - int received = function_call(generate_auto_ptr_B()); - ASSERT(received, - "auto_ptr in called function did not take ownership " - "from factory function with conversion"); - } -#endif - - { - kwsys::auto_ptr<A> pa(generate_auto_ptr_A()); - ASSERT(pa.get(), - "auto_ptr empty after construction from factory function"); - } - - { - kwsys::auto_ptr<A> pa; - pa = generate_auto_ptr_A(); - ASSERT(pa.get(), - "auto_ptr empty after assignment from factory function"); - } - - { - kwsys::auto_ptr<A> pa(generate_auto_ptr_B()); - ASSERT(pa.get(), - "auto_ptr empty after construction from compatible factory function"); - } - - { - kwsys::auto_ptr<A> pa; - pa = generate_auto_ptr_B(); - ASSERT(pa.get(), - "auto_ptr empty after assignment from compatible factory function"); - } - } - - ASSERT(instances == 0, "auto_ptr leaked an object"); - - return status; -} diff --git a/Tests/CMakeLists.txt b/Tests/CMakeLists.txt index 5911682..b3d61bd 100644 --- a/Tests/CMakeLists.txt +++ b/Tests/CMakeLists.txt @@ -274,6 +274,9 @@ if(BUILD_TESTING) endif() if(TEST_RESOURCES) ADD_TEST_MACRO(VSResource VSResource) + if (CMAKE_GENERATOR MATCHES "Ninja") + add_test_macro(VSResourceNinjaForceRSP VSResourceNinjaForceRSP) + endif () endif() ADD_TEST_MACRO(MSManifest MSManifest) ADD_TEST_MACRO(Simple Simple) diff --git a/Tests/Module/GenerateExportHeader/lib_shared_and_static/CMakeLists.txt b/Tests/Module/GenerateExportHeader/lib_shared_and_static/CMakeLists.txt index c1be125..a057746 100644 --- a/Tests/Module/GenerateExportHeader/lib_shared_and_static/CMakeLists.txt +++ b/Tests/Module/GenerateExportHeader/lib_shared_and_static/CMakeLists.txt @@ -25,9 +25,12 @@ add_library(shared_variant SHARED ${lib_SRCS}) set_target_properties(shared_variant PROPERTIES DEFINE_SYMBOL SHARED_VARIANT_MAKEDLL) add_library(static_variant ${lib_SRCS}) +set(MY_CUSTOM_CONTENT "#define MY_CUSTOM_CONTENT_ADDED") + generate_export_header(shared_variant BASE_NAME libshared_and_static PREFIX_NAME MYPREFIX_ + CUSTOM_CONTENT_FROM_VARIABLE MY_CUSTOM_CONTENT ) set_target_properties(static_variant PROPERTIES COMPILE_FLAGS -DLIBSHARED_AND_STATIC_STATIC_DEFINE) diff --git a/Tests/Module/GenerateExportHeader/lib_shared_and_static/libshared_and_static.cpp b/Tests/Module/GenerateExportHeader/lib_shared_and_static/libshared_and_static.cpp index 2764905..846c207 100644 --- a/Tests/Module/GenerateExportHeader/lib_shared_and_static/libshared_and_static.cpp +++ b/Tests/Module/GenerateExportHeader/lib_shared_and_static/libshared_and_static.cpp @@ -1,6 +1,10 @@ #include "libshared_and_static.h" +#ifndef MY_CUSTOM_CONTENT_ADDED +#error "MY_CUSTOM_CONTENT_ADDED not defined!" +#endif + int LibsharedAndStatic::libshared_and_static() const { return 0; diff --git a/Tests/RunCMake/try_compile/CMP0066-stderr.txt b/Tests/RunCMake/try_compile/CMP0066-stderr.txt new file mode 100644 index 0000000..b14e290 --- /dev/null +++ b/Tests/RunCMake/try_compile/CMP0066-stderr.txt @@ -0,0 +1,15 @@ +before try_compile with CMP0066 WARN-default +after try_compile with CMP0066 WARN-default +* +CMake Warning \(dev\) at CMP0066.cmake:[0-9]+ \(try_compile\): + Policy CMP0066 is not set: Honor per-config flags in try_compile\(\) + source-file signature. Run "cmake --help-policy CMP0066" for policy + details. Use the cmake_policy command to set the policy and suppress this + warning. + + For compatibility with older versions of CMake, try_compile is not honoring + caller config-specific compiler flags \(e.g. CMAKE_C_FLAGS_DEBUG\) in the + test project. +Call Stack \(most recent call first\): + CMakeLists.txt:[0-9]+ \(include\) +This warning is for project developers. Use -Wno-dev to suppress it.$ diff --git a/Tests/RunCMake/try_compile/CMP0066-stdout.txt b/Tests/RunCMake/try_compile/CMP0066-stdout.txt new file mode 100644 index 0000000..1eb2f83 --- /dev/null +++ b/Tests/RunCMake/try_compile/CMP0066-stdout.txt @@ -0,0 +1,4 @@ +-- try_compile with CMP0066 WARN-default worked as expected +-- try_compile with CMP0066 WARN-enabled worked as expected +-- try_compile with CMP0066 OLD worked as expected +-- try_compile with CMP0066 NEW worked as expected diff --git a/Tests/RunCMake/try_compile/CMP0066.cmake b/Tests/RunCMake/try_compile/CMP0066.cmake new file mode 100644 index 0000000..4b95251 --- /dev/null +++ b/Tests/RunCMake/try_compile/CMP0066.cmake @@ -0,0 +1,58 @@ +enable_language(C) +set(CMAKE_C_FLAGS_RELEASE "-DPP_ERROR ${CMAKE_C_FLAGS_DEBUG}") +set(CMAKE_TRY_COMPILE_CONFIGURATION Release) + +#----------------------------------------------------------------------------- +message("before try_compile with CMP0066 WARN-default") +try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/src.c + OUTPUT_VARIABLE out + ) +string(REPLACE "\n" "\n " out " ${out}") +if(NOT RESULT) + message(FATAL_ERROR "try_compile with CMP0066 WARN-default failed but should have passed:\n${out}") +else() + message(STATUS "try_compile with CMP0066 WARN-default worked as expected") +endif() +message("after try_compile with CMP0066 WARN-default") + +#----------------------------------------------------------------------------- +set(CMAKE_POLICY_WARNING_CMP0066 ON) +try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/src.c + OUTPUT_VARIABLE out + ) +string(REPLACE "\n" "\n " out " ${out}") +if(NOT RESULT) + message(FATAL_ERROR "try_compile with CMP0066 WARN-enabled failed but should have passed:\n${out}") +else() + message(STATUS "try_compile with CMP0066 WARN-enabled worked as expected") +endif() + +#----------------------------------------------------------------------------- +cmake_policy(SET CMP0066 OLD) +try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/src.c + OUTPUT_VARIABLE out + ) +string(REPLACE "\n" "\n " out " ${out}") +if(NOT RESULT) + message(FATAL_ERROR "try_compile with CMP0066 OLD failed but should have passed:\n${out}") +else() + message(STATUS "try_compile with CMP0066 OLD worked as expected") +endif() + +#----------------------------------------------------------------------------- +cmake_policy(SET CMP0066 NEW) +try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/src.c + OUTPUT_VARIABLE out + ) +string(REPLACE "\n" "\n " out " ${out}") +if(RESULT) + message(FATAL_ERROR "try_compile with CMP0066 NEW passed but should have failed:\n${out}") +elseif(NOT "x${out}" MATCHES "PP_ERROR is defined") + message(FATAL_ERROR "try_compile with CMP0066 NEW did not fail with PP_ERROR:\n${out}") +else() + message(STATUS "try_compile with CMP0066 NEW worked as expected") +endif() diff --git a/Tests/RunCMake/try_compile/CompileFlags.cmake b/Tests/RunCMake/try_compile/CompileFlags.cmake deleted file mode 100644 index d4dc074..0000000 --- a/Tests/RunCMake/try_compile/CompileFlags.cmake +++ /dev/null @@ -1,17 +0,0 @@ -enable_language(C) -set(CMAKE_C_FLAGS_RELEASE "-DPP_ERROR ${CMAKE_C_FLAGS_DEBUG}") - -#----------------------------------------------------------------------------- -set(CMAKE_TRY_COMPILE_CONFIGURATION Release) -try_compile(RESULT ${CMAKE_CURRENT_BINARY_DIR} - ${CMAKE_CURRENT_SOURCE_DIR}/src.c - OUTPUT_VARIABLE out - ) -string(REPLACE "\n" "\n " out " ${out}") -if(RESULT) - message(FATAL_ERROR "try_compile passed but should have failed:\n${out}") -elseif(NOT "x${out}" MATCHES "PP_ERROR is defined") - message(FATAL_ERROR "try_compile did not fail with PP_ERROR:\n${out}") -else() - message(STATUS "try_compile with per-config flag worked as expected") -endif() diff --git a/Tests/RunCMake/try_compile/RunCMakeTest.cmake b/Tests/RunCMake/try_compile/RunCMakeTest.cmake index ec099fe..522433a 100644 --- a/Tests/RunCMake/try_compile/RunCMakeTest.cmake +++ b/Tests/RunCMake/try_compile/RunCMakeTest.cmake @@ -25,7 +25,7 @@ run_cmake(TargetTypeInvalid) run_cmake(TargetTypeStatic) run_cmake(CMP0056) -run_cmake(CompileFlags) +run_cmake(CMP0066) if(RunCMake_GENERATOR MATCHES "Make|Ninja") # Use a single build tree for a few tests without cleaning. diff --git a/Tests/VSResourceNinjaForceRSP/CMakeLists.txt b/Tests/VSResourceNinjaForceRSP/CMakeLists.txt new file mode 100644 index 0000000..29ba0ce --- /dev/null +++ b/Tests/VSResourceNinjaForceRSP/CMakeLists.txt @@ -0,0 +1,7 @@ +cmake_minimum_required(VERSION 2.8.4) +project(VSResourceNinjaForceRSP) + +set(CMAKE_NINJA_FORCE_RESPONSE_FILE TRUE) + +add_library(ResourceLib lib.cpp test.rc) +add_executable(VSResourceNinjaForceRSP main.cpp test.rc) diff --git a/Tests/VSResourceNinjaForceRSP/lib.cpp b/Tests/VSResourceNinjaForceRSP/lib.cpp new file mode 100644 index 0000000..c912397 --- /dev/null +++ b/Tests/VSResourceNinjaForceRSP/lib.cpp @@ -0,0 +1,4 @@ +int lib() +{ + return 0; +} diff --git a/Tests/VSResourceNinjaForceRSP/main.cpp b/Tests/VSResourceNinjaForceRSP/main.cpp new file mode 100644 index 0000000..247411d --- /dev/null +++ b/Tests/VSResourceNinjaForceRSP/main.cpp @@ -0,0 +1,6 @@ +int main(int argc, char** argv) +{ + (void)argc; + (void)argv; + return 0; +} diff --git a/Tests/VSResourceNinjaForceRSP/test.rc b/Tests/VSResourceNinjaForceRSP/test.rc new file mode 100644 index 0000000..1ffade6 --- /dev/null +++ b/Tests/VSResourceNinjaForceRSP/test.rc @@ -0,0 +1,4 @@ +STRINGTABLE +BEGIN + 1234 "5" +END diff --git a/Utilities/Release/osx_release.cmake b/Utilities/Release/osx_release.cmake index 35705ed..e7e5ba4 100644 --- a/Utilities/Release/osx_release.cmake +++ b/Utilities/Release/osx_release.cmake @@ -13,6 +13,8 @@ set(CFLAGS "") set(CXXFLAGS "-stdlib=libc++") set(INITIAL_CACHE " CMAKE_BUILD_TYPE:STRING=Release +CMAKE_C_STANDARD:STRING=11 +CMAKE_CXX_STANDARD:STRING=11 CMAKE_OSX_ARCHITECTURES:STRING=x86_64 CMAKE_OSX_DEPLOYMENT_TARGET:STRING=10.7 CMAKE_SKIP_BOOTSTRAP_TEST:STRING=TRUE @@ -21,8 +23,6 @@ BUILD_QtDialog:BOOL=TRUE CMake_GUI_DISTRIBUTE_WITH_Qt_LGPL:STRING=3 CMake_INSTALL_DEPENDENCIES:BOOL=ON CMAKE_SKIP_RPATH:BOOL=TRUE -CMake_NO_C_STANDARD:BOOL=TRUE -CMake_NO_CXX_STANDARD:BOOL=TRUE CMake_TEST_NO_FindPackageModeMakefileTest:BOOL=TRUE ") set(ENV [[ diff --git a/Utilities/Scripts/clang-format.bash b/Utilities/Scripts/clang-format.bash index 760a8d4..a9ef62b 100755 --- a/Utilities/Scripts/clang-format.bash +++ b/Utilities/Scripts/clang-format.bash @@ -36,15 +36,19 @@ Example to format locally modified files staged for commit: Utilities/Scripts/clang-format.bash --cached -Example to format the current topic: +Example to format files modified by the most recent commit: - git filter-branch \ - --tree-filter "Utilities/Scripts/clang-format.bash --amend" \ - master.. + Utilities/Scripts/clang-format.bash --amend Example to format all files: Utilities/Scripts/clang-format.bash --tracked + +Example to format the current topic: + + git filter-branch \ + --tree-filter "Utilities/Scripts/clang-format.bash --tracked" \ + master.. ' die() { diff --git a/Utilities/Scripts/update-liblzma.bash b/Utilities/Scripts/update-liblzma.bash new file mode 100755 index 0000000..088eb91 --- /dev/null +++ b/Utilities/Scripts/update-liblzma.bash @@ -0,0 +1,30 @@ +#!/usr/bin/env bash + +set -e +set -x +shopt -s dotglob + +readonly name="liblzma" +readonly ownership="liblzma upstream <xz-devel@tukaani.org>" +readonly subtree="Utilities/cmliblzma" +readonly repo="http://git.tukaani.org/xz.git" +readonly tag="v5.0.8" +readonly shortlog=false +readonly paths=" + COPYING + src/common/common_w32res.rc + src/common/sysdefs.h + src/common/tuklib_integer.h + src/liblzma/ +" + +extract_source () { + git_archive + pushd "${extractdir}/${name}-reduced" + mv src/common . + mv src/liblzma . + rmdir src + popd +} + +. "${BASH_SOURCE%/*}/update-third-party.bash" diff --git a/Utilities/cmliblzma/CMakeLists.txt b/Utilities/cmliblzma/CMakeLists.txt index 8920536..e806680 100644 --- a/Utilities/cmliblzma/CMakeLists.txt +++ b/Utilities/cmliblzma/CMakeLists.txt @@ -182,10 +182,6 @@ SET(LZMA_SRCS liblzma/simple/x86.c ) -IF(WIN32 AND BUILD_SHARED_LIBS) - SET(LZMA_SRCS ${LZMA_SRCS} liblzma/liblzma_w32res.rc) -ENDIF() - CONFIGURE_FILE(config.h.in config.h @ONLY) INCLUDE_DIRECTORIES( @@ -209,7 +205,7 @@ ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "PathScale") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -woffall") ENDIF() -ADD_LIBRARY(cmliblzma ${LZMA_SRCS}) +ADD_LIBRARY(cmliblzma STATIC ${LZMA_SRCS}) IF(CMAKE_C_COMPILER_ID STREQUAL "XL") # Disable the XL compiler optimizer because it causes crashes diff --git a/Utilities/cmliblzma/README-CMake.txt b/Utilities/cmliblzma/README-CMake.txt deleted file mode 100644 index b512997..0000000 --- a/Utilities/cmliblzma/README-CMake.txt +++ /dev/null @@ -1,66 +0,0 @@ -The Utilities/cmliblzma directory contains a reduced distribution -of the liblzma source tree with only the library source code and -CMake build system. It is not a submodule; the actual content is part -of our source tree and changes can be made and committed directly. - -We update from upstream using Git's "subtree" merge strategy. A -special branch contains commits of upstream liblzma snapshots and -nothing else. No Git ref points explicitly to the head of this -branch, but it is merged into our history. - -Update liblzma from upstream as follows. Create a local branch to -explicitly reference the upstream snapshot branch head: - - git branch liblzma-upstream c289e634 - -Use a temporary directory to checkout the branch: - - mkdir liblzma-tmp - cd liblzma-tmp - git init - git pull .. liblzma-upstream - rm -rf * - -Now place the (reduced) liblzma content in this directory. See -instructions shown by - - git log c289e634 - -for help extracting the content from the upstream svn repo. Then run -the following commands to commit the new version. Substitute the -appropriate date and version number: - - git add --all - - GIT_AUTHOR_NAME='liblzma upstream' \ - GIT_AUTHOR_EMAIL='xz-devel@tukaani.org' \ - GIT_AUTHOR_DATE='Sun Jun 30 19:55:49 2013 +0300' \ - git commit -m 'liblzma 5.0.5-gb69900ed (reduced)' && - git commit --amend - -Edit the commit message to describe the procedure used to obtain the -content. Then push the changes back up to the main local repository: - - git push .. HEAD:liblzma-upstream - cd .. - rm -rf liblzma-tmp - -Create a topic in the main repository on which to perform the update: - - git checkout -b update-liblzma master - -Merge the liblzma-upstream branch as a subtree: - - git merge -s recursive -X subtree=Utilities/cmliblzma \ - liblzma-upstream - -If there are conflicts, resolve them and commit. Build and test the -tree. Commit any additional changes needed to succeed. - -Finally, run - - git rev-parse --short=8 liblzma-upstream - -to get the commit from which the liblzma-upstream branch must be started -on the next update. Edit the "git branch liblzma-upstream" line above to -record it, and commit this file. diff --git a/Utilities/cmliblzma/liblzma/api/lzma/block.h b/Utilities/cmliblzma/liblzma/api/lzma/block.h index 8a4bf23..e6710a7 100644 --- a/Utilities/cmliblzma/liblzma/api/lzma/block.h +++ b/Utilities/cmliblzma/liblzma/api/lzma/block.h @@ -318,6 +318,9 @@ extern LZMA_API(lzma_ret) lzma_block_header_encode( * The size of the Block Header must have already been decoded with * lzma_block_header_size_decode() macro and stored to block->header_size. * + * The integrity check type from Stream Header must have been stored + * to block->check. + * * block->filters must have been allocated, but they don't need to be * initialized (possible existing filter options are not freed). * diff --git a/Utilities/cmliblzma/liblzma/api/lzma/version.h b/Utilities/cmliblzma/liblzma/api/lzma/version.h index 66e9396..09866b9 100644 --- a/Utilities/cmliblzma/liblzma/api/lzma/version.h +++ b/Utilities/cmliblzma/liblzma/api/lzma/version.h @@ -22,7 +22,7 @@ */ #define LZMA_VERSION_MAJOR 5 #define LZMA_VERSION_MINOR 0 -#define LZMA_VERSION_PATCH 5 +#define LZMA_VERSION_PATCH 8 #define LZMA_VERSION_STABILITY LZMA_VERSION_STABILITY_STABLE #ifndef LZMA_VERSION_COMMIT diff --git a/Utilities/cmliblzma/liblzma/check/crc32_fast.c b/Utilities/cmliblzma/liblzma/check/crc32_fast.c index 13f65b4..c2c3cb7 100644 --- a/Utilities/cmliblzma/liblzma/check/crc32_fast.c +++ b/Utilities/cmliblzma/liblzma/check/crc32_fast.c @@ -20,7 +20,7 @@ #include "crc_macros.h" -// If you make any changes, do some bench marking! Seemingly unrelated +// If you make any changes, do some benchmarking! Seemingly unrelated // changes can very easily ruin the performance (and very probably is // very compiler dependent). extern LZMA_API(uint32_t) diff --git a/Utilities/cmliblzma/liblzma/check/sha256.c b/Utilities/cmliblzma/liblzma/check/sha256.c index c2c85eb..3af6aa6 100644 --- a/Utilities/cmliblzma/liblzma/check/sha256.c +++ b/Utilities/cmliblzma/liblzma/check/sha256.c @@ -80,7 +80,7 @@ static const uint32_t SHA256_K[64] = { static void -transform(uint32_t state[], const uint32_t data[]) +transform(uint32_t state[8], const uint32_t data[16]) { uint32_t W[16]; uint32_t T[8]; diff --git a/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_presets.c b/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_presets.c index 8af9b9f..9332abf 100644 --- a/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_presets.c +++ b/Utilities/cmliblzma/liblzma/lzma/lzma_encoder_presets.c @@ -16,8 +16,9 @@ extern LZMA_API(lzma_bool) lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) { - static const uint8_t dict_size_values[] = { 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 }; - static const uint8_t depth_values[] = { 4, 8, 24, 48 }; + static const uint8_t dict_pow2[] + = { 18, 20, 21, 22, 22, 23, 23, 24, 25, 26 }; + static const uint8_t depths[] = { 4, 8, 24, 48 }; const uint32_t level = preset & LZMA_PRESET_LEVEL_MASK; const uint32_t flags = preset & ~LZMA_PRESET_LEVEL_MASK; @@ -33,13 +34,13 @@ lzma_lzma_preset(lzma_options_lzma *options, uint32_t preset) options->lp = LZMA_LP_DEFAULT; options->pb = LZMA_PB_DEFAULT; - options->dict_size = UINT32_C(1) << dict_size_values[level]; + options->dict_size = UINT32_C(1) << dict_pow2[level]; if (level <= 3) { options->mode = LZMA_MODE_FAST; options->mf = level == 0 ? LZMA_MF_HC3 : LZMA_MF_HC4; options->nice_len = level <= 1 ? 128 : 273; - options->depth = depth_values[level]; + options->depth = depths[level]; } else { options->mode = LZMA_MODE_NORMAL; options->mf = LZMA_MF_BT4; @@ -365,7 +365,6 @@ KWSYS_CXX_SOURCES="\ SystemTools" KWSYS_FILES="\ - auto_ptr.hxx \ Directory.hxx \ Encoding.h \ Encoding.hxx \ @@ -1272,6 +1271,8 @@ cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP_BINARY_DIR \"${CMAKE_ cmake_report cmConfigure.h${_tmp} "#define CMAKE_BIN_DIR \"/bootstrap-not-insalled\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_DATA_DIR \"/bootstrap-not-insalled\"" cmake_report cmConfigure.h${_tmp} "#define CMAKE_BOOTSTRAP" +cmake_report cmConfigure.h${_tmp} "#define CM_NULLPTR 0" +cmake_report cmConfigure.h${_tmp} "#define CM_OVERRIDE" # Regenerate configured headers for h in Configure VersionConfig; do |