From 225c0ef88bf21c39694b51798390b87328a163de Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Sun, 6 Apr 2014 15:55:37 +0200 Subject: Features: Record for MSVC 2010-2013. --- Modules/Compiler/MSVC-CXX-FeatureTests.cmake | 65 ++++++++++++++++++++++++++++ Modules/Platform/Windows-MSVC-CXX.cmake | 4 ++ 2 files changed, 69 insertions(+) create mode 100644 Modules/Compiler/MSVC-CXX-FeatureTests.cmake diff --git a/Modules/Compiler/MSVC-CXX-FeatureTests.cmake b/Modules/Compiler/MSVC-CXX-FeatureTests.cmake new file mode 100644 index 0000000..18dea24 --- /dev/null +++ b/Modules/Compiler/MSVC-CXX-FeatureTests.cmake @@ -0,0 +1,65 @@ + +# Reference: http://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx +# http://blogs.msdn.com/b/vcblog/archive/2013/06/28/c-11-14-stl-features-fixes-and-breaking-changes-in-vs-2013.aspx + +set(_oldestSupported "_MSC_VER >= 1600") + +set(MSVC_2013 "_MSC_VER >= 1800") +set(_cmake_feature_test_cxx_alias_templates "${MSVC_2013}") +set(_cmake_feature_test_cxx_default_function_template_args "${MSVC_2013}") +set(_cmake_feature_test_cxx_defaulted_functions "${MSVC_2013}") +set(_cmake_feature_test_cxx_delegating_constructors "${MSVC_2013}") +set(_cmake_feature_test_cxx_deleted_functions "${MSVC_2013}") +set(_cmake_feature_test_cxx_explicit_conversions "${MSVC_2013}") +# http://thread.gmane.org/gmane.comp.lib.boost.devel/245202/focus=245221 +set(_cmake_feature_test_cxx_generalized_initializers "${MSVC_2013}") +set(_cmake_feature_test_cxx_nonstatic_member_init "${MSVC_2013}") +set(_cmake_feature_test_cxx_raw_string_literals "${MSVC_2013}") +set(_cmake_feature_test_cxx_uniform_initialization "${MSVC_2013}") +# Possibly broken: +# http://thread.gmane.org/gmane.comp.lib.boost.devel/244986/focus=245333 +set(_cmake_feature_test_cxx_variadic_templates "${MSVC_2013}") + +set(MSVC_2012 "_MSC_VER >= 1700") +set(_cmake_feature_test_cxx_decltype_incomplete_return_types "${MSVC_2012}") +set(_cmake_feature_test_cxx_enum_forward_declarations "${MSVC_2012}") +set(_cmake_feature_test_cxx_final "${MSVC_2012}") +set(_cmake_feature_test_cxx_range_for "${MSVC_2012}") +set(_cmake_feature_test_cxx_strong_enums "${MSVC_2012}") + +set(MSVC_2010 "_MSC_VER >= 1600") +set(_cmake_feature_test_cxx_auto_function "${MSVC_2010}") +set(_cmake_feature_test_cxx_auto_type "${MSVC_2010}") +set(_cmake_feature_test_cxx_decltype "${MSVC_2010}") +set(_cmake_feature_test_cxx_extended_friend_declarations "${MSVC_2010}") +set(_cmake_feature_test_cxx_extern_templates "${MSVC_2010}") +set(_cmake_feature_test_cxx_lambdas "${MSVC_2010}") +set(_cmake_feature_test_cxx_local_type_template_args "${MSVC_2010}") +set(_cmake_feature_test_cxx_long_long_type "${MSVC_2010}") +set(_cmake_feature_test_cxx_nullptr "${MSVC_2010}") +set(_cmake_feature_test_cxx_override "${MSVC_2010}") +set(_cmake_feature_test_cxx_right_angle_brackets "${MSVC_2010}") +set(_cmake_feature_test_cxx_rvalue_references "${MSVC_2010}") +set(_cmake_feature_test_cxx_static_assert "${MSVC_2010}") +set(_cmake_feature_test_cxx_template_template_parameters "${MSVC_2010}") +set(_cmake_feature_test_cxx_variadic_macros "${MSVC_2010}") + +# Currently unsupported: +# http://herbsutter.com/2013/11/18/visual-c-compiler-november-2013-ctp/ +# set(_cmake_feature_test_cxx_reference_qualified_functions ) +# set(_cmake_feature_test_cxx_inheriting_constructors ) +# set(_cmake_feature_test_cxx_alignas ) +# set(_cmake_feature_test_cxx_alignof ) +# set(_cmake_feature_test_cxx_thread_local ) +# set(_cmake_feature_test_cxx_func_identifier ) +# set(_cmake_feature_test_cxx_sizeof_member ) + +# set(_cmake_feature_test_cxx_user_literals ) +# set(_cmake_feature_test_cxx_unrestricted_unions ) +# set(_cmake_feature_test_cxx_unicode_literals ) +# set(_cmake_feature_test_cxx_inline_namespaces ) +# set(_cmake_feature_test_cxx_constexpr ) +# set(_cmake_feature_test_cxx_noexcept ) +# set(_cmake_feature_test_cxx_attributes ) + +set(_oldestSupported) diff --git a/Modules/Platform/Windows-MSVC-CXX.cmake b/Modules/Platform/Windows-MSVC-CXX.cmake index 0e85005..89885b8 100644 --- a/Modules/Platform/Windows-MSVC-CXX.cmake +++ b/Modules/Platform/Windows-MSVC-CXX.cmake @@ -4,3 +4,7 @@ if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0) set(_FS_CXX " /FS") endif() __windows_compiler_msvc(CXX) + +macro(cmake_record_cxx_compile_features) + record_compiler_features(CXX "" CMAKE_CXX_COMPILE_FEATURES) +endmacro() -- cgit v0.12 From 64c30bdc48d0a3e1da48fdbfeb200740fa5dac43 Mon Sep 17 00:00:00 2001 From: Robert Maynard Date: Mon, 22 Dec 2014 10:25:18 -0500 Subject: Features: Record for MSVC C++ 2015 and MSVC C 2010-2015. Initializer lists are only properly supported in 2015 and above. Previous Visual Studio releases said they supported initializer lists but silently produced bad code. --- Modules/Compiler/MSVC-C-FeatureTests.cmake | 23 ++++++++++ Modules/Compiler/MSVC-CXX-FeatureTests.cmake | 64 +++++++++++++++++++++------- Modules/Platform/Windows-MSVC-C.cmake | 2 + Modules/Platform/Windows-MSVC-CXX.cmake | 5 +++ 4 files changed, 78 insertions(+), 16 deletions(-) create mode 100644 Modules/Compiler/MSVC-C-FeatureTests.cmake diff --git a/Modules/Compiler/MSVC-C-FeatureTests.cmake b/Modules/Compiler/MSVC-C-FeatureTests.cmake new file mode 100644 index 0000000..e449358 --- /dev/null +++ b/Modules/Compiler/MSVC-C-FeatureTests.cmake @@ -0,0 +1,23 @@ + +# Reference: http://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx +# http://blogs.msdn.com/b/vcblog/archive/2013/06/28/c-11-14-stl-features-fixes-and-breaking-changes-in-vs-2013.aspx +# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx +# http://www.visualstudio.com/en-us/news/vs2015-preview-vs.aspx + +set(_cmake_oldestSupported "_MSC_VER >= 1300") + +set(MSVC_2010 "_MSC_VER >= 1600") +set(_cmake_feature_test_c_static_assert "${MSVC_2010}") +set(_cmake_feature_test_c_variadic_macros "${MSVC_2010}") + +set(MSVC_2003 "_MSC_VER >= 1300") +set(_cmake_feature_test_c_function_prototypes "${MSVC_2003}") + +# Currently unsupported: +# restrict requires the __restrict syntax in msvc +# set(_cmake_feature_test_c_restrict) + +# Unset all the variables that we don't need exposed. +# _cmake_oldestSupported is required by WriteCompilerDetectionHeader +set(MSVC_2010) +set(MSVC_2003) \ No newline at end of file diff --git a/Modules/Compiler/MSVC-CXX-FeatureTests.cmake b/Modules/Compiler/MSVC-CXX-FeatureTests.cmake index 18dea24..b238fde 100644 --- a/Modules/Compiler/MSVC-CXX-FeatureTests.cmake +++ b/Modules/Compiler/MSVC-CXX-FeatureTests.cmake @@ -1,8 +1,35 @@ # Reference: http://msdn.microsoft.com/en-us/library/vstudio/hh567368.aspx # http://blogs.msdn.com/b/vcblog/archive/2013/06/28/c-11-14-stl-features-fixes-and-breaking-changes-in-vs-2013.aspx +# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx +# http://www.visualstudio.com/en-us/news/vs2015-preview-vs.aspx -set(_oldestSupported "_MSC_VER >= 1600") + +set(_cmake_oldestSupported "_MSC_VER >= 1600") + +set(MSVC_2015 "_MSC_VER >= 1900") +set(_cmake_feature_test_cxx_alignas "${MSVC_2015}") +set(_cmake_feature_test_cxx_alignof "${MSVC_2015}") +set(_cmake_feature_test_cxx_binary_literals "${MSVC_2015}") +set(_cmake_feature_test_cxx_decltype_auto "${MSVC_2015}") +set(_cmake_feature_test_cxx_digit_separators "${MSVC_2015}") +set(_cmake_feature_test_cxx_func_identifier "${MSVC_2015}") +# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx +# Note 1. While previous version of VisualStudio said they supported this +# they silently produced bad code, and are now marked as having partial +# support +set(_cmake_feature_test_cxx_generalized_initializers "${MSVC_2015}") +set(_cmake_feature_test_cxx_generic_lambdas "${MSVC_2015}") +set(_cmake_feature_test_cxx_inheriting_constructors "${MSVC_2015}") +set(_cmake_feature_test_cxx_inline_namespaces "${MSVC_2015}") +set(_cmake_feature_test_cxx_lambda_init_captures "${MSVC_2015}") +set(_cmake_feature_test_cxx_noexcept "${MSVC_2015}") +set(_cmake_feature_test_cxx_return_type_deduction "${MSVC_2015}") +set(_cmake_feature_test_cxx_sizeof_member "${MSVC_2015}") +set(_cmake_feature_test_cxx_thread_local "${MSVC_2015}") +set(_cmake_feature_test_cxx_unicode_literals "${MSVC_2015}") +set(_cmake_feature_test_cxx_unrestricted_unions "${MSVC_2015}") +set(_cmake_feature_test_cxx_user_literals "${MSVC_2015}") set(MSVC_2013 "_MSC_VER >= 1800") set(_cmake_feature_test_cxx_alias_templates "${MSVC_2013}") @@ -11,14 +38,16 @@ set(_cmake_feature_test_cxx_defaulted_functions "${MSVC_2013}") set(_cmake_feature_test_cxx_delegating_constructors "${MSVC_2013}") set(_cmake_feature_test_cxx_deleted_functions "${MSVC_2013}") set(_cmake_feature_test_cxx_explicit_conversions "${MSVC_2013}") -# http://thread.gmane.org/gmane.comp.lib.boost.devel/245202/focus=245221 -set(_cmake_feature_test_cxx_generalized_initializers "${MSVC_2013}") set(_cmake_feature_test_cxx_nonstatic_member_init "${MSVC_2013}") set(_cmake_feature_test_cxx_raw_string_literals "${MSVC_2013}") set(_cmake_feature_test_cxx_uniform_initialization "${MSVC_2013}") # Possibly broken: # http://thread.gmane.org/gmane.comp.lib.boost.devel/244986/focus=245333 set(_cmake_feature_test_cxx_variadic_templates "${MSVC_2013}") +# Microsoft now states they support contextual conversions +# see footnote 6 at: +# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx +set(_cmake_feature_test_cxx_contextual_conversions "${MSVC_2013}") set(MSVC_2012 "_MSC_VER >= 1700") set(_cmake_feature_test_cxx_decltype_incomplete_return_types "${MSVC_2012}") @@ -42,24 +71,27 @@ set(_cmake_feature_test_cxx_right_angle_brackets "${MSVC_2010}") set(_cmake_feature_test_cxx_rvalue_references "${MSVC_2010}") set(_cmake_feature_test_cxx_static_assert "${MSVC_2010}") set(_cmake_feature_test_cxx_template_template_parameters "${MSVC_2010}") +set(_cmake_feature_test_cxx_trailing_return_types "${MSVC_2010}") set(_cmake_feature_test_cxx_variadic_macros "${MSVC_2010}") # Currently unsupported: # http://herbsutter.com/2013/11/18/visual-c-compiler-november-2013-ctp/ -# set(_cmake_feature_test_cxx_reference_qualified_functions ) -# set(_cmake_feature_test_cxx_inheriting_constructors ) -# set(_cmake_feature_test_cxx_alignas ) -# set(_cmake_feature_test_cxx_alignof ) -# set(_cmake_feature_test_cxx_thread_local ) -# set(_cmake_feature_test_cxx_func_identifier ) -# set(_cmake_feature_test_cxx_sizeof_member ) +# http://blogs.msdn.com/b/vcblog/archive/2014/11/17/c-11-14-17-features-in-vs-2015-preview.aspx -# set(_cmake_feature_test_cxx_user_literals ) -# set(_cmake_feature_test_cxx_unrestricted_unions ) -# set(_cmake_feature_test_cxx_unicode_literals ) -# set(_cmake_feature_test_cxx_inline_namespaces ) +# set(_cmake_feature_test_cxx_reference_qualified_functions ) # set(_cmake_feature_test_cxx_constexpr ) -# set(_cmake_feature_test_cxx_noexcept ) # set(_cmake_feature_test_cxx_attributes ) +# set(_cmake_feature_test_cxx_aggregate_default_initializers ) +# set(_cmake_feature_test_cxx_attribute_deprecated ) +# set(_cmake_feature_test_cxx_defaulted_move_initializers ) +# set(_cmake_feature_test_cxx_nonstatic_member_init ) +# set(_cmake_feature_test_cxx_relaxed_constexpr ) +# set(_cmake_feature_test_cxx_variable_templates ) + -set(_oldestSupported) +# Unset all the variables that we don't need exposed. +# _cmake_oldestSupported is required by WriteCompilerDetectionHeader +set(MSVC_2015) +set(MSVC_2013) +set(MSVC_2012) +set(MSVC_2010) diff --git a/Modules/Platform/Windows-MSVC-C.cmake b/Modules/Platform/Windows-MSVC-C.cmake index cbe1586..c7792eb 100644 --- a/Modules/Platform/Windows-MSVC-C.cmake +++ b/Modules/Platform/Windows-MSVC-C.cmake @@ -3,3 +3,5 @@ if(NOT CMAKE_C_COMPILER_VERSION VERSION_LESS 18.0) set(_FS_C " /FS") endif() __windows_compiler_msvc(C) + +set(CMAKE_C_STANDARD_DEFAULT 90) diff --git a/Modules/Platform/Windows-MSVC-CXX.cmake b/Modules/Platform/Windows-MSVC-CXX.cmake index 89885b8..ad56f68 100644 --- a/Modules/Platform/Windows-MSVC-CXX.cmake +++ b/Modules/Platform/Windows-MSVC-CXX.cmake @@ -5,6 +5,11 @@ if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 18.0) endif() __windows_compiler_msvc(CXX) +# No version of MSVC has full conformance to C++11. Therefore the +# __cplusplus macro always evaluates to 98 even if the compilers come with +# C++11/14/+ features enabled. +set(CMAKE_CXX_STANDARD_DEFAULT 98) + macro(cmake_record_cxx_compile_features) record_compiler_features(CXX "" CMAKE_CXX_COMPILE_FEATURES) endmacro() -- cgit v0.12 From f73718c9b893e1489f904cf30392742cb456c341 Mon Sep 17 00:00:00 2001 From: Robert Maynard Date: Tue, 6 Jan 2015 13:19:44 -0500 Subject: Features: Enable writing of MSVC compiler feature header. Notes: VS2015 and above are the only MSVC versions to support cxx_final, so remove usages from the tests, and instead only test for cxx_override. VS2012 and above to conform to cxx_decltype_incomplete_return_types proposal, but without support for auto return types the dcl.type.simple example in the proposal doesn't compile. VS2013 and above to conform to the updated cxx_contextual_conversions proposal, but VS2010 and above pass the test. Compilers such as MSVC have no explicit flags to enable C++11 mode, it just is always on. So only run the link tests with compilers that require a flag to specify the language version. --- Modules/WriteCompilerDetectionHeader.cmake | 5 +++-- Tests/CompileFeatures/CMakeLists.txt | 23 ++++++++++++++++++++++ Tests/CompileFeatures/genex_test.cpp | 2 +- .../WriteCompilerDetectionHeader/CMakeLists.txt | 16 +++++++++++++-- Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake | 9 +++++++-- 5 files changed, 48 insertions(+), 7 deletions(-) diff --git a/Modules/WriteCompilerDetectionHeader.cmake b/Modules/WriteCompilerDetectionHeader.cmake index 36b9706..bcaaafa 100644 --- a/Modules/WriteCompilerDetectionHeader.cmake +++ b/Modules/WriteCompilerDetectionHeader.cmake @@ -36,7 +36,7 @@ # PREFIX ClimbingStats # OUTPUT_FILES_VAR support_files # OUTPUT_DIR compilers -# COMPILERS GNU Clang +# COMPILERS GNU Clang MSVC # FEATURES cxx_variadic_templates # ) # install(FILES @@ -100,7 +100,7 @@ # write_compiler_detection_header( # FILE climbingstats_compiler_detection.h # PREFIX ClimbingStats -# COMPILERS GNU Clang AppleClang +# COMPILERS GNU Clang AppleClang MSVC # FEATURES cxx_variadic_templates # ) # @@ -316,6 +316,7 @@ function(write_compiler_detection_header GNU Clang AppleClang + MSVC ) set(_hex_compilers ADSP Borland Embarcadero SunPro) diff --git a/Tests/CompileFeatures/CMakeLists.txt b/Tests/CompileFeatures/CMakeLists.txt index b164f06..9fb8d1b 100644 --- a/Tests/CompileFeatures/CMakeLists.txt +++ b/Tests/CompileFeatures/CMakeLists.txt @@ -26,7 +26,18 @@ get_property(c_features GLOBAL PROPERTY CMAKE_C_KNOWN_FEATURES) foreach(feature ${c_features}) run_test(${feature} C) endforeach() + get_property(cxx_features GLOBAL PROPERTY CMAKE_CXX_KNOWN_FEATURES) + +if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + list(REMOVE_ITEM cxx_features + # This test requires auto return type deduction to work properly, but + # that is not supported by all versions of MSVC that support decltype + # incomplete return types. + cxx_decltype_incomplete_return_types + ) +endif() + foreach(feature ${cxx_features}) run_test(${feature} CXX) endforeach() @@ -53,6 +64,17 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" ) endif() +set(MSVC_) +if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND + MSVC_VERSION LESS 1800) + list(REMOVE_ITEM CXX_non_features + # Microsoft only officially supports this feature in VS2013 and above, due + # to new wording of the proposal. We don't test for this with MSVC because + # older compiler pass the test but might not actually conform + cxx_contextual_conversions + ) +endif() + set(C_ext c) set(C_standard_flag 11) set(CXX_ext cpp) @@ -126,6 +148,7 @@ if (CMAKE_CXX_COMPILE_FEATURES) add_executable(CompileFeaturesGenex genex_test.cpp) set_property(TARGET CompileFeaturesGenex PROPERTY CXX_STANDARD 11) + target_compile_definitions(CompileFeaturesGenex PRIVATE HAVE_OVERRIDE_CONTROL=$ HAVE_NULLPTR=$ diff --git a/Tests/CompileFeatures/genex_test.cpp b/Tests/CompileFeatures/genex_test.cpp index f667cc4..4412569 100644 --- a/Tests/CompileFeatures/genex_test.cpp +++ b/Tests/CompileFeatures/genex_test.cpp @@ -10,7 +10,7 @@ struct A virtual int getA() { return 7; } }; -struct B final : A +struct B : A { int getA() override { return 42; } }; diff --git a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt index 401de95..cfaa78c 100644 --- a/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt +++ b/Tests/Module/WriteCompilerDetectionHeader/CMakeLists.txt @@ -11,7 +11,7 @@ get_property(c_known_features GLOBAL PROPERTY CMAKE_C_KNOWN_FEATURES) write_compiler_detection_header( FILE "${CMAKE_CURRENT_BINARY_DIR}/test_compiler_detection.h" PREFIX TEST - COMPILERS GNU Clang AppleClang + COMPILERS GNU Clang AppleClang MSVC VERSION 3.1 PROLOG "// something" EPILOG "// more" @@ -64,6 +64,18 @@ if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" list(APPEND false_defs EXPECTED_COMPILER_CXX_VARIADIC_TEMPLATES) endif() +# for msvc the compiler version determines which c++11 features are available. +# Both variadic templates and delegating constructors support exist in +# all versions that we write compile headers for. +if (CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND + ";${CMAKE_CXX_COMPILE_FEATURES};" MATCHES ";cxx_delegating_constructors;") + list(APPEND true_defs EXPECTED_COMPILER_CXX_DELEGATING_CONSTRUCTORS) + list(APPEND true_defs EXPECTED_COMPILER_CXX_VARIADIC_TEMPLATES) +else(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC") + list(APPEND false_defs EXPECTED_COMPILER_CXX_DELEGATING_CONSTRUCTORS) + list(APPEND false_defs EXPECTED_COMPILER_CXX_VARIADIC_TEMPLATES) +endif() + if (CMAKE_C_COMPILER_ID STREQUAL "GNU" OR CMAKE_C_COMPILER_ID STREQUAL "Clang" OR CMAKE_C_COMPILER_ID STREQUAL "AppleClang") @@ -81,7 +93,7 @@ write_compiler_detection_header( PREFIX MULTI OUTPUT_FILES_VAR multi_files OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/compiler_multi_files/compiler_support" - COMPILERS GNU Clang AppleClang + COMPILERS GNU Clang AppleClang MSVC VERSION 3.1 FEATURES ${cxx_known_features} ${c_known_features} diff --git a/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake b/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake index 1892a5c..3b37091 100644 --- a/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake +++ b/Tests/RunCMake/CompileFeatures/RunCMakeTest.cmake @@ -27,8 +27,13 @@ if (NOT CXX_FEATURES) run_cmake(NoSupportedCxxFeatures) run_cmake(NoSupportedCxxFeaturesGenex) else() - run_cmake(LinkImplementationFeatureCycle) - run_cmake(LinkImplementationFeatureCycleSolved) + # compilers such as MSVC have no explicit flags to enable c++11 mode. + # Instead they come with all c++11 features implicitly enabled. + # So for those types of compilers this tests is not applicable. + if(CMAKE_CXX11_STANDARD_COMPILE_OPTION) + run_cmake(LinkImplementationFeatureCycle) + run_cmake(LinkImplementationFeatureCycleSolved) + endif() if (";${CXX_FEATURES};" MATCHES ";cxx_final;") set(RunCMake_TEST_OPTIONS "-DHAVE_FINAL=1") -- cgit v0.12 From 2d738ce37acda92b344b1d3f2be2d3b6df63763c Mon Sep 17 00:00:00 2001 From: Brad King Date: Sun, 11 Jan 2015 11:37:12 -0500 Subject: Help: Add notes for topic 'feature_record_msvc' --- Help/release/dev/feature_record_msvc.rst | 6 ++++++ 1 file changed, 6 insertions(+) create mode 100644 Help/release/dev/feature_record_msvc.rst diff --git a/Help/release/dev/feature_record_msvc.rst b/Help/release/dev/feature_record_msvc.rst new file mode 100644 index 0000000..63b642d --- /dev/null +++ b/Help/release/dev/feature_record_msvc.rst @@ -0,0 +1,6 @@ +feature_record_msvc +------------------- + +* The :manual:`Compile Features ` functionality + is now aware of features supported by Visual Studio 2010 and above + (``MSVC``). -- cgit v0.12