Update: Merge branch 'jgrpp_master_cmake' into jgrpp_cmake

2020-06-27 20:46:53 +12:00
parent 15c600d64f fd2a120c9d
commit cf8ea74733
329 changed files with 4044 additions and 32403 deletions
--- a/cmake/scripts/Baseset.cmake
+++ b/cmake/scripts/Baseset.cmake
@@ -0,0 +1,53 @@
+cmake_minimum_required(VERSION 3.5)
+
+#
+# Create a single baseset meta file with the correct translations.
+#
+
+set(ARGC 1)
+set(ARG_READ NO)
+
+# Read all the arguments given to CMake; we are looking for -- and everything
+# that follows. Those are our language files.
+while(ARGC LESS CMAKE_ARGC)
+    set(ARG ${CMAKE_ARGV${ARGC}})
+
+    if (ARG_READ)
+        list(APPEND LANG_SOURCE_FILES "${ARG}")
+    endif (ARG_READ)
+
+    if (ARG STREQUAL "--")
+        set(ARG_READ YES)
+    endif (ARG STREQUAL "--")
+
+    math(EXPR ARGC "${ARGC} + 1")
+endwhile()
+
+# Place holder format is @<ini_key>_<str_id>@
+file(STRINGS "${BASESET_SOURCE_FILE}" PLACE_HOLDER REGEX "^@")
+string(REGEX REPLACE "@([^_]+).*@" "\\1" INI_KEY "${PLACE_HOLDER}")
+string(REGEX REPLACE "@[^_]+_(.*)@" "\\1" STR_ID "${PLACE_HOLDER}")
+string(REGEX REPLACE "@(.*)@" "\\1" PLACE_HOLDER "${PLACE_HOLDER}")
+
+# Get the translations
+foreach(LANGFILE IN LISTS LANG_SOURCE_FILES)
+    file(STRINGS "${LANGFILE}" LANGLINES REGEX "^(##isocode|${STR_ID})" ENCODING UTF-8)
+    string(FIND "${LANGLINES}" "${STR_ID}" HAS_STR_ID)
+    if (HAS_STR_ID LESS 0)
+        continue()
+    endif (HAS_STR_ID LESS 0)
+    string(REGEX REPLACE "##isocode ([^;]+).*" "\\1" ISOCODE "${LANGLINES}")
+    if ("${ISOCODE}" STREQUAL "en_GB")
+        string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}       = \\1" LANGLINES "${LANGLINES}")
+    else()
+        string(REGEX REPLACE "[^:]*:(.*)" "${INI_KEY}.${ISOCODE} = \\1" LANGLINES "${LANGLINES}")
+    endif()
+    list(APPEND ${PLACE_HOLDER} ${LANGLINES})
+endforeach(LANGFILE)
+list(SORT ${PLACE_HOLDER})
+string(REPLACE ";" "\n" ${PLACE_HOLDER} "${${PLACE_HOLDER}}")
+
+# Get the grf md5
+file(MD5 ${BASESET_EXTRAGRF_FILE} ORIG_EXTRA_GRF_MD5)
+
+configure_file(${BASESET_SOURCE_FILE} ${BASESET_BINARY_FILE})
--- a/cmake/scripts/CreateGRF.cmake
+++ b/cmake/scripts/CreateGRF.cmake
@@ -0,0 +1,44 @@
+cmake_minimum_required(VERSION 3.5)
+
+#
+# Create a single GRF file based on sprites/<grfname>.nfo and sprites/*.png
+# files.
+#
+
+if (NOT NFORENUM_EXECUTABLE)
+    message(FATAL_ERROR "Script needs NFORENUM_EXECUTABLE defined")
+endif (NOT NFORENUM_EXECUTABLE)
+if (NOT GRFCODEC_EXECUTABLE)
+    message(FATAL_ERROR "Script needs GRFCODEC_EXECUTABLE defined")
+endif (NOT GRFCODEC_EXECUTABLE)
+if (NOT GRF_SOURCE_FOLDER)
+    message(FATAL_ERROR "Script needs GRF_SOURCE_FOLDER defined")
+endif (NOT GRF_SOURCE_FOLDER)
+if (NOT GRF_BINARY_FILE)
+    message(FATAL_ERROR "Script needs GRF_BINARY_FILE defined")
+endif (NOT GRF_BINARY_FILE)
+
+get_filename_component(GRF_SOURCE_FOLDER_NAME "${GRF_SOURCE_FOLDER}" NAME)
+
+file(WRITE sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "")
+file(READ ${GRF_SOURCE_FOLDER}/${GRF_SOURCE_FOLDER_NAME}.nfo NFO_LINES)
+# Replace ; with \;, and make a list out of this based on \n
+string(REPLACE ";" "\\;" NFO_LINES "${NFO_LINES}")
+string(REPLACE "\n" ";" NFO_LINES "${NFO_LINES}")
+
+foreach(NFO_LINE IN LISTS NFO_LINES)
+    # Recover the ; that was really in the text (and not a newline)
+    string(REPLACE "\\;" ";" NFO_LINE "${NFO_LINE}")
+
+    if (NFO_LINE MATCHES "^#include")
+        string(REGEX REPLACE "^#include \"(.*)\"$" "\\1" INCLUDE_FILE ${NFO_LINE})
+        file(READ ${GRF_SOURCE_FOLDER}/${INCLUDE_FILE} INCLUDE_LINES)
+        file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${INCLUDE_LINES}")
+    else (NFO_LINE MATCHES "^#include")
+        file(APPEND sprites/${GRF_SOURCE_FOLDER_NAME}.nfo "${NFO_LINE}\n")
+    endif (NFO_LINE MATCHES "^#include")
+endforeach(NFO_LINE)
+
+execute_process(COMMAND ${NFORENUM_EXECUTABLE} -s sprites/${GRF_SOURCE_FOLDER_NAME}.nfo)
+execute_process(COMMAND ${GRFCODEC_EXECUTABLE} -n -s -e -p1 ${GRF_SOURCE_FOLDER_NAME}.grf)
+execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${GRF_SOURCE_FOLDER_NAME}.grf ${GRF_BINARY_FILE})
--- a/cmake/scripts/FindVersion.cmake
+++ b/cmake/scripts/FindVersion.cmake
@@ -0,0 +1,140 @@
+cmake_minimum_required(VERSION 3.5)
+
+#
+# Finds the current version of the current folder.
+#
+
+find_package(Git QUIET)
+# ${CMAKE_SOURCE_DIR}/.git may be a directory or a regular file
+if (GIT_FOUND AND EXISTS "${CMAKE_SOURCE_DIR}/.git")
+    # Make sure LC_ALL is set to something desirable
+    set(SAVED_LC_ALL "$ENV{LC_ALL}")
+    set(ENV{LC_ALL} C)
+
+    # Assume the dir is not modified
+    set(REV_MODIFIED 0)
+
+    # Refresh the index to make sure file stat info is in sync, then look for modifications
+    execute_process(COMMAND ${GIT_EXECUTABLE} update-index --refresh
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                    OUTPUT_QUIET
+    )
+
+    # See if git tree is modified
+    execute_process(COMMAND ${GIT_EXECUTABLE} diff-index HEAD
+                    OUTPUT_VARIABLE IS_MODIFIED
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    )
+    if (NOT IS_MODIFIED STREQUAL "")
+        set(REV_MODIFIED 2)
+    endif()
+
+    # Get last commit hash
+    execute_process(COMMAND ${GIT_EXECUTABLE} rev-parse --verify HEAD
+                    OUTPUT_VARIABLE FULLHASH
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                    ERROR_QUIET
+    )
+    set(REV_HASH "${FULLHASH}")
+
+    string(SUBSTRING "${FULLHASH}" 0 10 SHORTHASH)
+
+    # Get the last commit date
+    execute_process(COMMAND ${GIT_EXECUTABLE} show -s --pretty=format:%ci HEAD
+                    OUTPUT_VARIABLE COMMITDATE
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+    )
+    string(REGEX REPLACE "([0-9]+)-([0-9]+)-([0-9]+).*" "\\1\\2\\3" COMMITDATE "${COMMITDATE}")
+    set(REV_ISODATE "${COMMITDATE}")
+    string(SUBSTRING "${REV_ISODATE}" 0 4 REV_YEAR)
+
+    # Get the branch
+    execute_process(COMMAND ${GIT_EXECUTABLE} symbolic-ref -q HEAD
+                    OUTPUT_VARIABLE BRANCH
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                    ERROR_QUIET
+    )
+    string(REGEX REPLACE ".*/" "" BRANCH "${BRANCH}")
+
+    # Get the tag
+    execute_process(COMMAND ${GIT_EXECUTABLE} describe --tags
+                    OUTPUT_VARIABLE TAG
+                    OUTPUT_STRIP_TRAILING_WHITESPACE
+                    WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+                    ERROR_QUIET
+    )
+    string(REGEX REPLACE "\^0$" "" TAG "${TAG}")
+
+    if (REV_MODIFIED EQUAL 0)
+        set(HASHPREFIX "-g")
+    elseif (REV_MODIFIED EQUAL 2)
+        set(HASHPREFIX "-m")
+    else ()
+        set(HASHPREFIX "-u")
+    endif()
+
+    # Set the version string
+    if (NOT TAG STREQUAL "")
+        set(REV_VERSION "${TAG}")
+        set(REV_ISTAG 1)
+
+        string(REGEX REPLACE "^[0-9.]*$" "" STABLETAG "${TAG}")
+        if (NOT STABLETAG STREQUAL "")
+            set(REV_ISSTABLETAG 1)
+        else ()
+            set(REV_ISSTABLETAG 0)
+        endif ()
+    else ()
+        set(REV_VERSION "${REV_ISODATE}-${BRANCH}${HASHPREFIX}${SHORTHASH}")
+        set(REV_ISTAG 0)
+        set(REV_ISSTABLETAG 0)
+    endif ()
+
+    # Restore LC_ALL
+    set(ENV{LC_ALL} "${SAVED_LC_ALL}")
+elseif (EXISTS "${CMAKE_SOURCE_DIR}/.ottdrev")
+    file(READ "${CMAKE_SOURCE_DIR}/.ottdrev" OTTDREV)
+    string(REPLACE "\n" "" OTTDREV "${OTTDREV}")
+    string(REPLACE "\t" ";" OTTDREV "${OTTDREV}")
+    list(GET OTTDREV 0 REV_VERSION)
+    list(GET OTTDREV 1 REV_ISODATE)
+    list(GET OTTDREV 2 REV_MODIFIED)
+    list(GET OTTDREV 3 REV_HASH)
+    list(GET OTTDREV 4 REV_ISTAG)
+    list(GET OTTDREV 5 REV_ISSTABLETAG)
+    list(GET OTTDREV 6 REV_YEAR)
+else ()
+    message(WARNING "No version detected; this build will NOT be network compatible")
+    set(REV_VERSION "norev0000")
+    set(REV_ISODATE "19700101")
+    set(REV_MODIFIED 1)
+    set(REV_HASH "unknown")
+    set(REV_ISTAG 0)
+    set(REV_ISSTABLETAG 0)
+    set(REV_YEAR "1970")
+endif ()
+
+message(STATUS "Version string: ${REV_VERSION}")
+
+if (GENERATE_OTTDREV)
+    message(STATUS "Generating .ottdrev")
+    file(WRITE ${CMAKE_SOURCE_DIR}/.ottdrev "${REV_VERSION}\t${REV_ISODATE}\t${REV_MODIFIED}\t${REV_HASH}\t${REV_ISTAG}\t${REV_ISSTABLETAG}\t${REV_YEAR}\n")
+else (GENERATE_OTTDREV)
+    message(STATUS "Generating rev.cpp")
+    configure_file("${CMAKE_SOURCE_DIR}/src/rev.cpp.in"
+            "${FIND_VERSION_BINARY_DIR}/rev.cpp")
+
+    if (WIN32)
+        message(STATUS "Generating ottdres.rc")
+        configure_file("${CMAKE_SOURCE_DIR}/src/os/windows/ottdres.rc.in"
+                "${FIND_VERSION_BINARY_DIR}/ottdres.rc")
+    endif (WIN32)
+
+    message(STATUS "Generating CPackProperties.cmake")
+    configure_file("${CMAKE_SOURCE_DIR}/CPackProperties.cmake.in"
+            "${CPACK_BINARY_DIR}/CPackProperties.cmake" @ONLY)
+endif (GENERATE_OTTDREV)
--- a/cmake/scripts/Regression.cmake
+++ b/cmake/scripts/Regression.cmake
@@ -0,0 +1,97 @@
+cmake_minimum_required(VERSION 3.5)
+
+#
+# Runs a single regressoion test
+#
+
+if (NOT REGRESSION_TEST)
+    message(FATAL_ERROR "Script needs REGRESSION_TEST defined (tip: use -DREGRESSION_TEST=..)")
+endif (NOT REGRESSION_TEST)
+if (NOT OPENTTD_EXECUTABLE)
+    message(FATAL_ERROR "Script needs OPENTTD_EXECUTABLE defined (tip: use -DOPENTTD_EXECUTABLE=..)")
+endif (NOT OPENTTD_EXECUTABLE)
+
+if (NOT EXISTS ai/${REGRESSION_TEST}/test.sav)
+    message(FATAL_ERROR "Regression test ${REGRESSION_TEST} does not exist (tip: check regression folder for the correct spelling)")
+endif ()
+
+# If editbin is given, copy the executable to a new folder, and change the
+# subsystem to console. The copy is needed as multiple regressions can run
+# at the same time.
+if (EDITBIN_EXECUTABLE)
+    execute_process(COMMAND ${CMAKE_COMMAND} -E copy ${OPENTTD_EXECUTABLE} regression/${REGRESSION_TEST}.exe)
+    set(OPENTTD_EXECUTABLE "regression/${REGRESSION_TEST}.exe")
+
+    execute_process(COMMAND ${EDITBIN_EXECUTABLE} /nologo /subsystem:console ${OPENTTD_EXECUTABLE})
+endif (EDITBIN_EXECUTABLE)
+
+# Run the regression test
+execute_process(COMMAND ${OPENTTD_EXECUTABLE}
+                        -x
+                        -c regression/regression.cfg
+                        -g ai/${REGRESSION_TEST}/test.sav
+                        -snull
+                        -mnull
+                        -vnull:ticks=30000
+                        -d script=2
+                        -d misc=9
+                OUTPUT_VARIABLE REGRESSION_OUTPUT
+                ERROR_VARIABLE REGRESSION_RESULT
+                OUTPUT_STRIP_TRAILING_WHITESPACE
+                ERROR_STRIP_TRAILING_WHITESPACE
+)
+
+if (REGRESSION_OUTPUT)
+    message(FATAL_ERROR "Unexpected output: ${REGRESSION_OUTPUT}")
+endif (REGRESSION_OUTPUT)
+
+if (NOT REGRESSION_RESULT)
+    message(FATAL_ERROR "Regression did not output anything; did the compilation fail?")
+endif (NOT REGRESSION_RESULT)
+
+# For some reason pointer can be printed as '0x(nil)', '0x0000000000000000', or '0x0x0'
+string(REPLACE "0x(nil)" "0x00000000" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "0x0000000000000000" "0x00000000" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "0x0x0" "0x00000000" REGRESSION_RESULT "${REGRESSION_RESULT}")
+
+# Convert the output to a format that is expected (and more readable) by result.txt
+string(REPLACE "\ndbg: [script]" "\n" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "\n " "\nERROR: " REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "\nERROR: [1] " "\n" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "\n[P] " "\n" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REGEX REPLACE "dbg: ([^\n]*)\n?" "" REGRESSION_RESULT "${REGRESSION_RESULT}")
+
+# Read the expected result
+file(READ ai/${REGRESSION_TEST}/result.txt REGRESSION_EXPECTED)
+
+# Convert the string to a list
+string(REPLACE "\n" ";" REGRESSION_RESULT "${REGRESSION_RESULT}")
+string(REPLACE "\n" ";" REGRESSION_EXPECTED "${REGRESSION_EXPECTED}")
+
+set(ARGC 0)
+set(ERROR NO)
+
+list(LENGTH REGRESSION_EXPECTED REGRESSION_EXPECTED_LENGTH)
+
+# Compare the output
+foreach(RESULT IN LISTS REGRESSION_RESULT)
+    list(GET REGRESSION_EXPECTED ${ARGC} EXPECTED)
+
+    if (NOT RESULT STREQUAL EXPECTED)
+        message("${ARGC}: - ${EXPECTED}")
+        message("${ARGC}: + ${RESULT}'")
+        set(ERROR YES)
+    endif (NOT RESULT STREQUAL EXPECTED)
+
+    math(EXPR ARGC "${ARGC} + 1")
+endforeach(RESULT)
+
+if (NOT REGRESSION_EXPECTED_LENGTH EQUAL ARGC)
+    math(EXPR MISSING "${REGRESSION_EXPECTED_LENGTH} - ${ARGC}")
+    message("(${MISSING} more lines were expected than found)")
+    set(ERROR YES)
+endif (NOT REGRESSION_EXPECTED_LENGTH EQUAL ARGC)
+
+if (ERROR)
+    message(FATAL_ERROR "Regression failed")
+endif (ERROR)