Merge pull request #25 from silnrsi/feature-cmake-fetchcontent

Replace the custom NuGet wrangling with the more flexible, and cross-platform, FetchContent module, for grabbing the ICU dependency.

Author: tim-eves

CMakeLists.txt

@@ -1,14 +1,17 @@
 cmake_minimum_required(VERSION 3.11)
-include(TestBigEndian)
-include(GNUInstallDirs)
 project(grcompiler)
+enable_language(CXX C)
+enable_testing()
+
+include(TestBigEndian)
+include(FetchContent)
 include(CTest)
 
-enable_language(CXX C)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_STANDARD_REQUIRED 11)
+include(GNUInstallDirs)
+
 
-enable_testing()
 
 if (NOT CMAKE_BUILD_TYPE)
     set_property(CACHE CMAKE_BUILD_TYPE PROPERTY VALUE Release)
@@ -17,22 +20,8 @@ endif()
 if  (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     add_definitions(-D_SCL_SECURE_NO_WARNINGS -D_CRT_SECURE_NO_WARNINGS -DWIN32 -D_WINDOWS)
 
-    if (NOT DEFINED ICU_ROOT)
-        find_program(NUGET nuget)
-        if(NOT NUGET)
-            file(DOWNLOAD https://dist.nuget.org/win-x86-commandline/latest/nuget.exe ${CMAKE_BINARY_DIR}/nuget.exe)
-            find_program(NUGET nuget PATHS ${CMAKE_BINARY_DIR})
-            if (NOT NUGET)
-                message(FATAL_ERROR "CMake could not find the nuget command line tool. Please install it or provide ICU_ROOT.")
-            endif()
-        endif()
-        
-        # Copy the Nuget config file from source location to the CMake build directory.
-        configure_file(packages.config.in packages.config COPYONLY)
-        # Run Nuget using the .config file to install any missing dependencies to the build directory.
-        execute_process(
-            COMMAND ${NUGET} restore packages.config -SolutionDirectory ${CMAKE_BINARY_DIR}
-            WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+    if (NOT DEFINED ICU_ROOT AND NOT DEFINED FETCHCONTENT_SOURCE_DIR_ICU)
+        set(ICU_URL https://github.com/unicode-org/icu/releases/download/release-66-1/icu4c-66_1-Win32-MSVC2017.zip)
     endif()
 endif()
 

README.md

@@ -19,7 +19,7 @@ path to it should be specified using the GDLPP environment variable
 naming may be needed.) or placed in the same folder as grcompiler.
 
 - GrcRegressionTest is used to regression test grcompiler against a set of
-reference GDL files and fonts. The regression tests are typically ran using
+reference GDL files and fonts. The regression tests are typically ran using 
 project files (see below).
 
 ### GDLPP #include details
@@ -134,20 +134,20 @@ You will need libc++ and libc++-abi packages.
 
 #### Windows specific details
 
-Visual Studio 2017 added support for handling CMake projects. You can find
+Visual Studio 2017 added support for handling CMake projects. You can find 
 more information and instructions at 
 [CMake projects in Visual Studio](https://docs.microsoft.com/en-us/cpp/build/cmake-projects-in-visual-studio?view=vs-2019).
 
-TIPS:
-- After generating the project files and optionally doing inital building and
-testing (above), the easiest way for Visual Studio developers to proceed is to
+TIPS:  
+- After generating the project files and optionally doing inital building and 
+testing (above), the easiest way for Visual Studio developers to proceed is to 
 open the `grcompiler.sln` file that cmake generates.
 
-- The Solution Explorer will contain projects for `grcompiler`, `gdlpp`, and
-`GrcRegressionTest`, as well as several other projects, some of which are just
+- The Solution Explorer will contain projects for `grcompiler`, `gdlpp`, and 
+`GrcRegressionTest`, as well as several other projects, some of which are just 
 empty standard test targets that cmake generates.
 
-- Do NOT switch the Solution Explorer to Folder View as that will cause cmake
+- Do NOT switch the Solution Explorer to Folder View as that will cause cmake 
 project generation to be redone using the Ninja generator (see below).
 
 - Right clicking on the grcompiler project and setting it as the Startup
@@ -158,7 +158,7 @@ Project is advisable.
 - Right clicking on RUN_TESTS and Building will run the regression tests.
 
 If development with cmake is preferred, in Visual Studio 2019,`File-Open-CMake...`
-can be used to open the CMakeCache.txt file. Using `File-Open Folder...' is not
+can be used to open the CMakeCache.txt file. Using `File-Open Folder...` is not
 advisable, since the Ninja project generator will be used. It seems buggy.
 FWIW, it's harder to specify the arguments to use for debugging with cmake 
 development compared to using the sln file.
@@ -177,57 +177,75 @@ The CMake approach above is strongly encouraged.
 The choice of 32- or 64-bit build tools and targets is made by building
 from the appropriate Visual Studio command prompt.
 
-To build grcomiler release binaries, from the `compiler` folder:  
-    ```
-    nmake -f makefile.mak
-    ```
-
-To build grcompiler debug binaries:  
-    ```
-    nmake CFG=DEBUG -f makefile.mak
-    ```
+To build grcomiler release binaries, from the `compiler` folder:
+```
+nmake -f makefile.mak
+```
 
-TIP: A debug build for ICU from source may be needed too (see below).  
+To build grcompiler debug binaries:
+```
+nmake CFG=DEBUG -f makefile.mak
+```
 
-Cleaning up, to remove all .obj files without removing the binaries:  
-    ```
-    nmake -f makefile.mak clean
-    ```
+TIP: A debug build for ICU from source will be needed too (see below).
 
-To remove the binaries as well:  
-    ```
-    nmake -f makefile.mak realclean
-    ```
+Cleaning up, to remove all .obj files without removing the binaries:
+```
+nmake -f makefile.mak clean
+```
 
+To remove the binaries as well:
+```
+nmake -f makefile.mak realclean
+```
 This deletes the libraries as well.  
 
-To build gdlpp, from the `preprocessor` folder:  
-    ```
-    nmake -f gdlpp.mak
-    ```
+To build gdlpp, from the `preprocessor` folder:
+```
+nmake -f gdlpp.mak
+```
 
-To build GrcRegressionTest and run regression tests,  
-from the `test/GrcRegressionTest` folder:  
-    `nmake -f Makefile.vc`  
-    `cd fonts`  
-    `nmake -f regtest.mak`  
+To build GrcRegressionTest and run regression tests, from the 
+`test/GrcRegressionTest` folder:
+```  
+nmake -f Makefile.vc  
+cd fonts  
+nmake -f regtest.mak  
+```  
 
 To use Visual Studio, setup a new makefile project and add commands
 for building, testing, and debugging using the makefiles indicated above.
 
 ## DEPENDENCIES
 ### ICU
 
+The grcompiler executable has a hard build dependency on ICU. This
+dependency may be satisfied via a system supplied dev package as is common on
+Linux, or via a pre-built binary distribution archive available from the
+[ICU4C project](http://site.icu-project.org/download/). 
+
+- CMake:
+    This will automatically download and unpack any archive URL passed to it
+    via `ICU_URL`. It will search for ICU includes and libraries in the root 
+    of that archive expecting to find `include`, `lib` and `bin` directories.
+    If those dirs are deeper inside the archive (e.g. inside usr/local) then 
+    passing the relative archive path in `ICU_ROOT` will cause it to search
+    there. If you have a local binary copy, e.g. if you are patching ICU too, 
+    you can have it use that instead by passing the path in 
+    `FETCHCONTENT_SOURCE_DIR_ICU`. Lastly passing just `ICU_ROOT` as a 
+    semi-colon separated list of paths to search allows you to use an ICU
+    distribution where executables, includes and libraries aren't neatly 
+    arranged. This might be the case if you want to pass both debug and 
+    release builds of ICU on Windows, in which case it will link the 
+    appopriate version.
+
 #### Linux
 
 You should use your distributions package manager to install icu-dev package.
 
 - CMake:
-    It will automatically find the system dev package installed by you package
-    manager. Setting the CMake variable ICU_ROOT to an abolute path will
-    override this process and use the built copy located at the provided path.
-    This can be set by passing `-DICU_ROOT=<path to built ICU files>` to the
-    `cmake` configuration invocation.
+    By default it will automatically find the system dev package installed by 
+    your package manager via the use of pkg-config.  
 - autotools:
     This will auto detect the icu installation via the use of pkg-config
     To overide the detection you need to provide compiler and linker flags via
@@ -236,34 +254,20 @@ You should use your distributions package manager to install icu-dev package.
 
 #### Windows
 
-The Graphite compiler requires library modules from ICU.
-
-- CMake:  
-    The CMakeLists.txt will automatically fetch the icu4c.v140 nuget package
-    for you and also a copy of nuget if it's not installed. Modify
-    `packages.config.in` to update the version.  Setting the ICU_ROOT CMake
-    variable to the semicolon separated list of directories which contain the
-    `.lib` stub files for the ICU DLLS and the include directory allows you to
-    use the official pre-built ICU distribution. In addition you will need to
-    set ICU_REDIST_ROOT to the path where the DLLs are if you want testing to
-    work as the build script will need to copy them.
-    .e.g if you unzip the downloaded ICU distribution into a dir called `icu`
-    in the top of the source tree you would pass these to `cmake`:  
-    `-DICU_ROOT="..\icu\lib;..\icu\include"` and 
-    `-DICU_REDIST_ROOT="..\icu\bin"` in addition to the usual arguments.
-- Nmake:  
-    You will need to download the ICU binaries from the following web
-    site: http://site.icu-project.org/download/  
-    - Create an icu folder under this project's top level folder and unzip
+- CMake:
+    If no `ICU_URL`, `FETCHCONTENT_SOURCE_DIR_ICU` or `ICU_ROOT` parameter is
+    passed then it will automatically set `ICU_URL` to a recent release and
+    proceed as above, by downloading and using that archive.
+- Nmake:
+  - Create an icu folder under this project's top level folder and unzip
     the archive into it.  
-    - makefile.mak copies the needed binaries to the folder where grcompiler
+  - makefile.mak copies the needed binaries to the folder where grcompiler
     is built. You may need to modify the file names for the icu/bin/*.dll
     files in makefile.mak since the file names include the version number
     of icu.  
-    - The icu project only supplies release versions of the binaries. So, when
+  - The icu project only supplies release versions of the binaries. So, when
     building a debug version of grcompiler, it is linked to release versions
     of the ICU dlls. To link to debug versions instead, icu binaries have to be
     built from source and makefile.mak adjusted to use them. In the icu source,
     there is a VisualStudio file in the source\allinone directory that can be
     used to build the binaries. The "common" project is the one to build.
-    Good luck!

compiler/CMakeLists.txt

@@ -1,20 +1,23 @@
 project(compiler VERSION 5.2)
 cmake_policy(SET CMP0074 NEW)
 
-if (DEFINED NUGET)
-    file(GLOB _icu_nuget_libs_paths "${CMAKE_BINARY_DIR}/packages/icu4c.v*/build/native/lib/*/*")
-    file(GLOB _icu_nuget_incs_paths "${CMAKE_BINARY_DIR}/packages/icu4c.v*/build/native/include")
-    file(GLOB ICU_REDIST_ROOT "${CMAKE_BINARY_DIR}/packages/icu4c.v*.redist.*/build/native/bin")
-    set(ICU_REDIST_ROOT "${ICU_REDIST_ROOT}/${CMAKE_VS_PLATFORM_NAME}")
+FetchContent_Declare(icu URL ${ICU_URL})
 
-    set(ICU_ROOT
-        ${_icu_nuget_libs_paths}
-        ${_icu_nuget_incs_paths}
-        ${ICU_ROOT})
-    message(STATUS "Using NuGet ICU package.")
+if (DEFINED ICU_URL OR DEFINED FETCHCONTENT_SOURCE_DIR_ICU)
+    FetchContent_GetProperties(icu)
+    if (NOT icu_POPULATED)
+        message(STATUS "Fetching: " ${ICU_URL})
+        FetchContent_Populate(icu)
+    endif()
+
+    if (icu_POPULATED)
+        set(ICU_ROOT ${icu_SOURCE_DIR}/${ICU_ROOT})
+    else()
+        set(ICU_ROOT "")
+    endif()
 endif()
 
-find_package(ICU REQUIRED COMPONENTS uc i18n)
+find_package(ICU REQUIRED COMPONENTS uc i18n data)
 message(STATUS "ICU Libraries: " ${ICU_VERSION})
 
 add_subdirectory(Generic)
@@ -53,16 +56,19 @@ add_executable(grcompiler
     PostParser.cpp 
     $<TARGET_OBJECTS:TtfUtil>
     main.cpp)
-target_link_libraries(grcompiler ${ICU_I18N_LIBRARY} ${ICU_UC_LIBRARY} generic parser lz4)
 
 if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
     target_compile_options(grcompiler PRIVATE /Zc:wchar_t- /W3 /EHsc)
+endif()
+
+target_link_libraries(grcompiler ICU::uc ICU::i18n generic parser lz4)
 
-    if (DEFINED ICU_REDIST_ROOT)
-        get_filename_component(ICU_REDIST_ROOT ${ICU_REDIST_ROOT} ABSOLUTE)
+if (icu_POPULATED)
+    if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+        file(GLOB_RECURSE _icu_dlls "${icu_SOURCE_DIR}/**${CMAKE_SHARED_LIBRARY_SUFFIX}")
         add_custom_command(TARGET grcompiler POST_BUILD 
-            COMMAND ${CMAKE_COMMAND} -E copy_directory
-                "${ICU_REDIST_ROOT}/$<$<BOOL:${NUGET}>:$<CONFIGURATION>>"
+            COMMAND ${CMAKE_COMMAND} -E copy_if_different
+                ${_icu_dlls}
                 $<TARGET_FILE_DIR:grcompiler>)
     endif()
 endif()

packages.config.in

@@ -25,7 +25,7 @@ function(compile_test FONT VERSION PSNAME)
     add_test(NAME compile_${FONT}
         COMMAND grcompiler -D -v${VERSION} ${ARGN} -e ${PROJECT_BINARY_DIR}/${FONT}.gdlerr.txt ${FONT_SOURCE_DIR}/${_input}Main.gdl ${FONT_SOURCE_DIR}/${_input}Input.ttf ${FONT}.ttf ${PSNAME})
     set_tests_properties(compile_${FONT} PROPERTIES
-        ENVIRONMENT GDLPP=$<TARGET_FILE:gdlpp>
+        ENVIRONMENT "GDLPP=$<TARGET_FILE:gdlpp>;LD_LIBRARY_PATH=$LD_LIBRARY_PATH:${ICU_INCLUDE_DIR}/../lib"
 #        ATTACHED_FILES ${PROJECT_BINARY_DIR}/${FONT}.gdlerr.log
         REQUIRED_FILES "${FONT_SOURCE_DIR}/${_input}Input.ttf;${FONT_SOURCE_DIR}/${_input}Main.gdl"
         WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
@@ -50,21 +50,14 @@ function(compile_test FONT VERSION PSNAME)
 endfunction()
 
 function(get_icu_dirs)
-    if(ICU_INCLUDE_DIR AND EXISTS "${ICU_INCLUDE_DIR}/unicode/uvernum.h")
-        file(STRINGS "${ICU_INCLUDE_DIR}/unicode/uvernum.h" icu_header_str
-        REGEX "^#define[\t ]+U_ICU_VERSION[\t ]+\".*\".*")
-
-        string(REGEX REPLACE "^#define[\t ]+U_ICU_VERSION[\t ]+\"([^ \\n.]*)(\.[^ \\n]*)?\".*"
-        "\\1" icu_version_string "${icu_header_str}")
-    endif()
-
+    string(REGEX MATCH "^[0-9]+" icu_major_version ${ICU_VERSION})
     file(GLOB icuders RELATIVE ${FONT_SOURCE_DIR} CONFIGURE_DEPENDS 
         ${FONT_SOURCE_DIR}/icu*)
     list(TRANSFORM icuders REPLACE "icu([0-9]+)$" "\\1")
     list(SORT icuders)
     list(REVERSE icuders)
     foreach(ver IN LISTS icuders)
-        if (${ver} LESS_EQUAL ${icu_version_string})
+        if (${ver} LESS_EQUAL ${icu_major_version})
             list(APPEND ICUDIRS "${ver}")
         endif()
     endforeach()