leapmotion · yeswalrus · Aug 11, 2016 · Jun 1, 2016 · Jun 18, 2016 · Jun 18, 2016
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -1,16 +1,14 @@
 cmake_minimum_required(VERSION 3.4)
 include(version.cmake)
-project(Autowiring VERSION ${autowiring_VERSION})
 include("standard/Standard.cmake")
 
+standard_project(Autowiring VERSION ${autowiring_VERSION})
+
 list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/cmake-modules")
 include(AddPCH)
 include(ConditionalSources)
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
-# Standard calls
-set_standard_output_variables()
-
 # We have unit test projects via googletest, they're added in the places where they are defined
 enable_testing()
 

diff --git a/standard/CombinedInstaller.cmake b/standard/CombinedInstaller.cmake
@@ -54,7 +54,7 @@ function(combined_installer)
   if(CMAKE_CONFIGURATION_TYPES)
     default_value(ARG_CONFIGS ${CMAKE_CONFIGURATION_TYPES})
   endif()
-  default_value(ARG_WIXFILE ${CMAKE_BINARY_DIR}/CMakeFiles/standard_WixFile.wxs)
+  default_value(ARG_WIXFILE "${CMAKE_BINARY_DIR}/CMakeFiles/standard_WixFile.wxs")
   default_value(ARG_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE.txt")
   default_value(ARG_README "${CMAKE_CURRENT_SOURCE_DIR}/README.md")
 
@@ -113,13 +113,13 @@ function(combined_installer)
       list(
         APPEND
         CPACK_INSTALL_COMMANDS
-        "${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR} --config ${ONE_CONFIG}"
+        "${CMAKE_COMMAND} --build \\\"${CMAKE_BINARY_DIR}\\\" --config ${ONE_CONFIG}"
         "${CMAKE_COMMAND} -DBUILD_TYPE=${ONE_CONFIG} -P \\\"${SELF}/cmake_package.cmake\\\""
       )
     endforeach()
   else()
     set(CPACK_INSTALL_COMMANDS
-      "${CMAKE_COMMAND} --build ${CMAKE_BINARY_DIR}"
+      "${CMAKE_COMMAND} --build \\\"${CMAKE_BINARY_DIR}\\\""
       "${CMAKE_COMMAND} -P \\\"${SELF}/cmake_package.cmake\\\""
     )
   endif()

diff --git a/standard/README.md b/standard/README.md
@@ -25,14 +25,18 @@ Provides a sort of global header that can be used by all customers of this libra
 include("standard/Standard.cmake")
 ```
 
-### [SetStandardOutputVariables](SetStandardOutputVariables.cmake)
+### [StandardProject](StandardProject.cmake)
 
 There are a lot of options that have to be configured in order to get CMake building on all platforms with broadly compatible options for C++11.  This file handles all of that work, but also handles the task of standardizing the build directories and making sure that your compiler of choice can actually handle C++11.
 
-This module defines one function taking no arguments which should be invoked as so:
+This module defines a wrapper around project, which is itself a wrapper around project() with a pre-initialization and post-initialization function called in the correct order. This is required because some variables must be set prior to the first call to project, while other settings are conditional based on information that is only available after.
 
 ```CMake
-set_standard_output_variables()
+standard_project(project VERSION version [LANGUAGES ...])
+# OR
+standard_project_preinit()
+project(...)
+standard_project_postinit()
 
 # Now your source code
 add_subdirectory(src)
@@ -61,8 +65,8 @@ This module ensures this by doing the following:
 0. Figures out the architecture that you're targeting.  Right now we support ARM, x86, and x64
 0. Creates a file called `MyLibraryTargets.cmake` which includes all of the projects in your library which were installed with the cmake [`install`](https://cmake.org/cmake/help/v3.5/command/install.html) command.
 0. Creates `projectname-config.cmake` which specifies the right include directories for installed and local builds, and brings in `MyLibraryTargets.cmake`
-0. Creates `projectname-configVersion` which... 
-  * ...uses semantic versioning to ensure that `find_package(mylibrary 2.0.2)` correctly matches version `2.0.5` but not version `1.9.2` 
+0. Creates `projectname-configVersion` which...
+  * ...uses semantic versioning to ensure that `find_package(mylibrary 2.0.2)` correctly matches version `2.0.5` but not version `1.9.2`
   * ...validates architecture compatibility by not allowing an ARM build to accidentally link with an x86 library
   * ...handles the case of fat binaries, where both x86 and x64 builds can link to the same spot
 
@@ -80,7 +84,7 @@ install(
   CONFIGURATIONS ${CMAKE_CONFIGURATION_TYPES}
 )
 install_headers(TARGET MyLibrary)
-generate_version()  
+generate_version()
 ```
 
 ### [CombinedInstaller](CombinedInstaller.cmake)

diff --git a/standard/SetStandardOutputVariables.cmake b/standard/SetStandardOutputVariables.cmake
diff --git a/standard/Standard.cmake b/standard/Standard.cmake
@@ -2,12 +2,11 @@
 list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
 
 # Need these for the rest of these scripts to work properly
-include(CTest)
 include(CheckTypeSize)
 
 # Omnibus include file that brings in all standard CMake scripts
 include(CombinedInstaller)
 include(DefaultValue)
 include(GenerateVersion)
-include(SetStandardOutputVariables)
+include(StandardProject)
 include(InstallHeaders)
diff --git a/standard/StandardProject.cmake b/standard/StandardProject.cmake
@@ -0,0 +1,129 @@
+#[[
+Simple project setup. There's a fair amount of boiler plate that has to happen
+in a particular order around project setup. This function wraps project() and
+does the following:
+
+* Changes CMake around so that the output variables follow the /bin and /lib output
+  directory convention popular on Gnu.
+* Ensures that ARM and 64-bit code are built as position-independent code
+* Verifies that the compiler actually supports C++11
+* Sets the correct flags to enable C++11 on all platforms
+* Ensures compilation happens with visibility set to hidden by default
+* Builds fat binaries on mac
+* Sets standard_BUILD* variables for consumption later down the line.
+* Enforces the project has a VERSION set.
+]]
+
+#This must be a macro since project defines scope-local variables
+#that we generally rely on being in the root context.
+macro(standard_project project_name)
+  cmake_parse_arguments(standard "" "VERSION" "LANGUAGES" ${ARGN})
+  if(NOT standard_VERSION)
+    message(FATAL_ERROR "Standard compliant projects must specify a version")
+  endif()
+
+  set(_language_arg "")
+  if(standard_LANGUAGES)
+    set(_language_arg LANGUAGES ${standard_LANGUAGES})
+  endif()
+
+  standard_project_preinit()
+  project(${project_name} VERSION ${standard_VERSION} ${_language_arg})
+  standard_project_postinit()
+endmacro()
+
+function(standard_project_preinit)
+  # Pre-initialization steps - these variables must be set before the first call to
+  # project()
+  if(APPLE)
+    if(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm")
+      set(CMAKE_OSX_ARCHITECTURES "arm" CACHE STRING "Mac OS X build architectures")
+    else()
+      # Build Fat binaries on OSX by default
+      set(CMAKE_OSX_ARCHITECTURES "x86_64;i386" CACHE STRING "Mac OS X build architectures")
+    endif()
+  endif()
+
+  #These do not strictly *have* to be set prior to project, but they can be so we will
+
+  # Need to classify the architecture before we run anything else, this lets us easily configure the
+  # find version file based on what the architecture was actually built to be
+  if(CMAKE_SYSTEM_PROCESSOR STREQUAL "arm")
+    set(standard_BUILD_ARM ON CACHE INTERNAL "")
+    set(standard_BUILD_ARCHITECTURES "arm" CACHE INTERNAL "")
+    set(standard_BUILD_64 OFF CACHE INTERNAL "")
+  elseif(CMAKE_OSX_ARCHITECTURES STREQUAL "x86_64;i386")
+    set(standard_BUILD_ARCHITECTURES x64 x86 CACHE INTERNAL "")
+    set(standard_BUILD_64 ON CACHE INTERNAL "")
+  elseif(CMAKE_SIZEOF_VOID_P STREQUAL 4)
+    set(standard_BUILD_ARCHITECTURES "x86" CACHE INTERNAL "")
+    set(standard_BUILD_64 OFF CACHE INTERNAL "")
+  else()
+    set(standard_BUILD_ARCHITECTURES "x64" CACHE INTERNAL "")
+    set(standard_BUILD_64 ON CACHE INTERNAL "")
+  endif()
+  message(STATUS "Using architecture: ${standard_BUILD_ARCHITECTURES}")
+
+   # All of our binaries go to one place:  The binaries output directory.  We only want to tinker
+  # with this if we're building by ourselves, otherwise we just do whatever the enclosing project
+  # wants us to do.
+  set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/bin CACHE INTERNAL "Executable Output directory")
+
+  # Libraries not only all wind up in the libraries directory, but we also keep them all together
+  # here by putting them in the same place, regardless of whether they are debug or release.  This
+  # makes globbing them together much easier.
+  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Shared Library output directory")
+  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Shared Library output directory")
+  set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Shared Library output directory")
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Static Library output directory")
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_DEBUG ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Static Library output directory")
+  set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_RELEASE ${CMAKE_BINARY_DIR}/lib CACHE INTERNAL "Static Library output directory")
+
+  # Postfix on all debug libraries should be "d"
+  set(CMAKE_DEBUG_POSTFIX d${CMAKE_DEBUG_POSTFIX} CACHE INTERNAL "Debug postfix")
+
+  # 64-bit installations should suffix with 64 regardless of the CPU type (arm or intel)
+  if(CMAKE_SIZEOF_VOID_P EQUAL 8)
+    foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
+      string(TOUPPER ${config} config)
+      set(CMAKE_${config}_POSTFIX "${CMAKE_${config}_POSTFIX}64" CACHE INTERNAL "$[config} Postfix")
+    endforeach()
+  endif()
+
+  # We want Position independent code for all builds
+  set(CMAKE_POSITION_INDEPENDENT_CODE ON CACHE INTERNAL "Position-Independent Code")
+endfunction()
+
+function(standard_project_postinit)
+  ##Post-initialization steps. All of these depend on project() having been called.
+
+  include(CTest)
+
+  if(CMAKE_COMPILER_IS_GNUCC)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.8")
+      message(FATAL_ERROR "GCC version 4.8 minimum is required to build ${CMAKE_PROJECT_NAME}")
+    endif()
+  elseif (MSVC)
+    if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS "18.0")
+      message(FATAL_ERROR "MSVC 2013 minimum is required to build ${CMAKE_PROJECT_NAME}")
+    endif()
+  endif()
+  message(STATUS "Compiler version ${CMAKE_CXX_COMPILER_VERSION}")
+
+  # Always use c++11 compiler with hidden visibility
+  if(NOT WIN32)
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -fvisibility=hidden" CACHE INTERNAL "C++ Compiler Flags")
+  endif()
+
+  # Clang needs special additional flags to build with C++11
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "AppleClang")
+    message(STATUS "AppleClang C++11")
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -stdlib=libc++" CACHE INTERNAL "C++ Compiler Flags")
+    set(CMAKE_XCODE_ATTRIBUTE_CLANG_CXX_LIBRARY "libc++" CACHE INTERNAL "XCode Clang C++ STL Version")
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
+    message(STATUS "Clang C++11")
+    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS}-lstdc++" CACHE INTERNAL "C++ EXE Linker Flags")
+  elseif(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    message(STATUS "GCC C++11")
+  endif()
+endfunction()
diff --git a/standard/standard-configVersion.cmake.in b/standard/standard-configVersion.cmake.in
@@ -1,7 +1,4 @@
 set(PACKAGE_VERSION "@ARG_VERSION@")
-set(PACKAGE_VERSION_MAJOR "@ARG_VERSION_MAJOR@")
-set(PACKAGE_VERSION_MINOR "@ARG_VERSION_MINOR@")
-set(PACKAGE_VERSION_PATCH "@ARG_VERSION_PATCH@")
 
 if(@ARG_NAME@_DEBUG)
   message(STATUS "Debug mode on")
@@ -93,12 +90,12 @@ elseif(PACKAGE_VERSION VERSION_LESS PACKAGE_FIND_VERSION)
     message(STATUS "Our version is less than the requested one, trivially incompatible")
   endif()
   set(PACKAGE_VERSION_COMPATIBLE FALSE)
-elseif(NOT PACKAGE_FIND_VERSION_MINOR EQUAL PACKAGE_VERSION_MINOR)
+elseif(NOT PACKAGE_FIND_VERSION_MINOR EQUAL "@ARG_VERSION_MINOR@")
   if(@ARG_NAME@_DEBUG)
     message(STATUS "Minor version mismatch, requested minor is ${PACKAGE_FIND_VERSION_MINOR}, this version is ${PACKAGE_VERSION_MINOR}")
   endif()
   set(PACKAGE_VERSION_COMPATIBLE FALSE)
-elseif(NOT PACKAGE_FIND_VERSION_MAJOR EQUAL PACKAGE_VERSION_MAJOR)
+elseif(NOT PACKAGE_FIND_VERSION_MAJOR EQUAL "@ARG_VERSION_MAJOR@")
   if(@ARG_NAME@_DEBUG)
     message(STATUS "Major version mismatch, failure.")
   endif()

diff --git a/standard/toolchain-arm32.cmake b/standard/toolchain-arm32.cmake
@@ -7,9 +7,6 @@ set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
-list(APPEND CMAKE_CXX_FLAGS "-fPIC")
-list(APPEND CMAKE_C_FLAGS "-fPIC")
-
 foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
   string(TOUPPER ${config} config)
   string(CONCAT CMAKE_${config}_POSTFIX "${CMAKE_${config}_POSTFIX}" "64")

diff --git a/standard/toolchain-arm64.cmake b/standard/toolchain-arm64.cmake
@@ -7,9 +7,6 @@ set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER)
 set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY)
 set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY)
 
-list(APPEND CMAKE_CXX_FLAGS "-fPIC")
-list(APPEND CMAKE_C_FLAGS "-fPIC")
-
 foreach(config IN LISTS CMAKE_CONFIGURATION_TYPES)
   string(TOUPPER ${config} config)
   string(CONCAT CMAKE_${config}_POSTFIX "${CMAKE_${config}_POSTFIX}" "64")