Add C++11 feature checks

CMakeLists.txt

@@ -48,6 +48,7 @@ include(CheckSymbolExists)
 set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake") # For custom cmake modules
 include(BuildType)
 include(CompileCheck)
+include(CXX11Check)
 include(Doxygen)
 include(PrintConfiguration)
 include(StyleCheck)
@@ -142,23 +143,14 @@ add_definitions(${iconv_DEFINITIONS})
 
 # Set compiler flags
 
-set(INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE "unsigned long")
-if(MSVC)
-	if(NOT MSVC_VERSION LESS 1600)
-		# MSVC 10+
-		set(INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE   "unsigned long long")
-		set(INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16 ON)
-		set(INNOEXTRACT_HAVE_STD_UNIQUE_PTR         ON)
-	endif()
-elseif(${Boost_VERSION} LESS 104800)
+if(${Boost_VERSION} LESS 104800)
 	# Older Boost versions don't work with C++11
 elseif(USE_CXX11)
-	add_cxxflag("-std=c++11")
-	if(FLAG_FOUND)
-		set(INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE "unsigned long long")
-		set(INNOEXTRACT_HAVE_STD_UNIQUE_PTR       ON)
+	enable_cxx11()
+	check_cxx11("std::unique_ptr" INNOEXTRACT_HAVE_STD_UNIQUE_PTR)
+	if(WIN32)
+		check_cxx11("std::codecvt_utf8_utf16" INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16)
 	endif()
-	# missing check for INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16
 endif()
 
 # Don't expose internal symbols to the outside world by default

cmake/CXX11Check.cmake

@@ -0,0 +1,32 @@
+
+include(CheckCXXSourceCompiles)
+include(CompileCheck)
+
+set(_HAS_CXX11 0)
+
+function(enable_cxx11)
+	if(MSVC)
+		set(_HAS_CXX11 1 PARENT_SCOPE)
+	else()
+		add_cxxflag("-std=c++11")
+		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" PARENT_SCOPE)
+		if(FLAG_FOUND OR NOT CMAKE_COMPILER_IS_GNUCXX)
+			set(_HAS_CXX11 1 PARENT_SCOPE)
+		endif()
+	endif()
+endfunction(enable_cxx11)
+
+function(check_cxx11 CHECK RESULTVAR)
+	if(${_HAS_CXX11})
+		string(REGEX REPLACE "[^a-zA-Z0-9_][^a-zA-Z0-9_]*" "-" check "${CHECK}")
+		set(file "${CMAKE_MODULE_PATH}/check-cxx11-${check}.cpp")
+		check_compile(result "${file}" "${CHECK}" "C++11 feature")
+		if("${result}" STREQUAL "")
+			set(${RESULTVAR} OFF PARENT_SCOPE)
+		else()
+			set(${RESULTVAR} ON PARENT_SCOPE)
+		endif()
+	else()
+		set(${RESULTVAR} OFF PARENT_SCOPE)
+	endif()
+endfunction()

cmake/CompileCheck.cmake

@@ -17,10 +17,13 @@
 #    misrepresented as being the original software.
 # 3. This notice may not be removed or altered from any source distribution.
 
-function(check_flag RESULT FLAG TYPE)
+function(check_compile RESULT FILE FLAG TYPE)
+	
+	string(REGEX REPLACE "[^a-zA-Z0-9_][^a-zA-Z0-9_]*" "-" cachevar "${TYPE}-${FLAG}")
+	set(cahevar "CHECK_COMPILE_${cahevar}")
 	
-	if(DEFINED CHECK_COMPILER_FLAG_${FLAG})
-		if(CHECK_COMPILER_FLAG_${FLAG})
+	if(DEFINED ${cachevar})
+		if(${cachevar})
 			set(${RESULT} "${FLAG}" PARENT_SCOPE)
 		else()
 			set(${RESULT} "" PARENT_SCOPE)
@@ -57,19 +60,17 @@ function(check_flag RESULT FLAG TYPE)
 	set(old_CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}")
 	set(old_CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS}")
 	set(old_CMAKE_MODULE_LINKER_FLAGS "${CMAKE_MODULE_LINKER_FLAGS}")
-	if("${TYPE}" STREQUAL linker)
+	if("${TYPE}" STREQUAL "linker flag")
 		set(CMAKE_EXE_LINKER_FLAGS "${old_CMAKE_EXE_LINKER_FLAGS} ${FLAG}")
 		set(CMAKE_SHARED_LINKER_FLAGS "${old_CMAKE_SHARED_LINKER_FLAGS} ${FLAG}")
 		set(CMAKE_MODULE_LINKER_FLAGS "${old_CMAKE_MODULE_LINKER_FLAGS} ${FLAG}")
-	else()
+	elseif("${TYPE}" STREQUAL "compiler flag")
 		set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${FLAG}")
 	endif()
 	
 	# Check if we can compile and link a simple file with the new flags
-	set(compile_test_file "${CMAKE_CURRENT_BINARY_DIR}/compile_flag_test.cpp")
-	file(WRITE ${compile_test_file} "__attribute__((const)) int main(){ return 0; }\n")
 	try_compile(
-		CHECK_COMPILER_FLAG ${CMAKE_BINARY_DIR} ${compile_test_file}
+		check_compiler_flag ${CMAKE_BINARY_DIR} ${FILE}
 		CMAKE_FLAGS "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}"
 		            "-DCMAKE_EXE_LINKER_FLAGS=${CMAKE_EXE_LINKER_FLAGS}"
 		            "-DCMAKE_SHARED_LINKER_FLAGS=${CMAKE_SHARED_LINKER_FLAGS}"
@@ -83,10 +84,10 @@ function(check_flag RESULT FLAG TYPE)
 	set(CMAKE_SHARED_LINKER_FLAGS "${old_CMAKE_SHARED_LINKER_FLAGS}")
 	set(CMAKE_MODULE_LINKER_FLAGS "${old_CMAKE_MODULE_LINKER_FLAGS}")
 	
-	if(NOT CHECK_COMPILER_FLAG)
-		message(STATUS "Checking ${TYPE} flag: ${FLAG} - unsupported")
+	if(NOT check_compiler_flag)
+		message(STATUS "Checking ${TYPE}: ${FLAG} - unsupported")
 		set(${RESULT} "" PARENT_SCOPE)
-		set("CHECK_COMPILER_FLAG_${FLAG}" 0 CACHE INTERNAL "...")
+		set("${cachevar}" 0 CACHE INTERNAL "...")
 	else()
 		
 		set(has_warning 0)
@@ -97,17 +98,24 @@ function(check_flag RESULT FLAG TYPE)
 		endforeach()
 		
 		if(has_warning)
-			message(STATUS "Checking ${TYPE} flag: ${FLAG} - unsupported (warning)")
+			message(STATUS "Checking ${TYPE}: ${FLAG} - unsupported (warning)")
 			set(${RESULT} "" PARENT_SCOPE)
-			set("CHECK_COMPILER_FLAG_${FLAG}" 0 CACHE INTERNAL "...")
+			set("${cachevar}" 0 CACHE INTERNAL "...")
 		else()
-			message(STATUS "Checking ${TYPE} flag: ${FLAG}")
+			message(STATUS "Checking ${TYPE}: ${FLAG}")
 			set(${RESULT} "${FLAG}" PARENT_SCOPE)
-			set("CHECK_COMPILER_FLAG_${FLAG}" 1 CACHE INTERNAL "...")
+			set("${cachevar}" 1 CACHE INTERNAL "...")
 		endif()
 		
 	endif()
 	
+endfunction(check_compile)
+
+function(check_flag RESULT FLAG TYPE)
+	set(compile_test_file "${CMAKE_CURRENT_BINARY_DIR}/compile_flag_test.cpp")
+	file(WRITE ${compile_test_file} "__attribute__((const)) int main(){ return 0; }\n")
+	check_compile(result "${compile_test_file}" "${FLAG}" "${TYPE} flag")
+	set(${RESULT} "${result}" PARENT_SCOPE)
 endfunction(check_flag)
 
 function(check_compiler_flag RESULT FLAG)

cmake/check-cxx11-std-codecvt_utf8_utf16.cpp

@@ -0,0 +1,6 @@
+#include <codecvt>
+
+int main() {
+	std::codecvt_utf8_utf16<wchar_t> codecvt;
+	return 0;
+}

cmake/check-cxx11-std-unique_ptr.cpp

@@ -0,0 +1,6 @@
+#include <memory>
+
+int main() {
+	std::unique_ptr<char> ptr(new char);
+	return !ptr;
+}

src/configure.hpp.in

@@ -26,7 +26,6 @@
 #cmakedefine01 INNOEXTRACT_HAVE_BSWAP_64
 
 // C++11 functionality
-#define INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE ${INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE}
 #cmakedefine01 INNOEXTRACT_HAVE_STD_CODECVT_UTF8_UTF16
 #cmakedefine01 INNOEXTRACT_HAVE_STD_UNIQUE_PTR
 

src/util/storedenum.hpp

@@ -23,6 +23,7 @@
 
 #include <stddef.h>
 #include <vector>
+#include <bitset>
 
 #include <boost/cstdint.hpp>
 #include <boost/static_assert.hpp>
@@ -130,19 +131,13 @@ public:
 	
 	operator std::bitset<size>() const {
 		
-		// Make `make style` shut up since we really need unsigned long here.
-		typedef INNOEXTRACT_STD_BITSET_CONSTRUCT_TYPE construct_type;
-		
-		static const size_t construct_size = sizeof(construct_type) * 8;
-		
-		BOOST_STATIC_ASSERT(base_size % construct_size == 0 || base_size < construct_size);
+		#define concat(a, b) a##b
+		BOOST_STATIC_ASSERT(sizeof(base_type) <= sizeof(concat(unsi, gned) concat(lo, ng)));
+		#undef concat
 		
 		std::bitset<size> result(0);
 		for(size_t i = 0; i < count; i++) {
-			for(size_t j = 0; j < util::ceildiv(base_size, construct_size); j++) {
-				construct_type chunk = static_cast<construct_type>(bits[i] >> (j * construct_size));
-				result |= std::bitset<size>(chunk) << ((i * base_size) + (j * construct_size));
-			}
+			result |= std::bitset<size>(bits[i]) << (i * base_size);
 		}
 		return result;
 	}