203 lines
6.8 KiB
CMake
203 lines
6.8 KiB
CMake
macro(get_sub_dirs result curdir)
|
|
FILE(GLOB children RELATIVE ${curdir} ${curdir}/*)
|
|
SET(dirlist "")
|
|
FOREACH (child ${children})
|
|
IF (IS_DIRECTORY ${curdir}/${child})
|
|
LIST(APPEND dirlist ${child})
|
|
ENDIF ()
|
|
ENDFOREACH ()
|
|
SET(${result} ${dirlist})
|
|
endmacro(get_sub_dirs)
|
|
|
|
function(recursive_zip_folder in_dir out_dir)
|
|
get_filename_component(FROM_DIR_NAME ${in_dir} NAME)
|
|
set(TMP_FILE_DIR ${CMAKE_BINARY_DIR}/tmp/${name})
|
|
get_sub_dirs(SUB_DIRS "${in_dir}")
|
|
file(MAKE_DIRECTORY ${out_dir})
|
|
|
|
foreach (ZIP_DIR ${SUB_DIRS})
|
|
if ("${ZIP_DIR}" STREQUAL ".git")
|
|
continue()
|
|
endif ()
|
|
|
|
file(GLOB_RECURSE ZIP_FILES LIST_DIRECTORIES TRUE "${in_dir}/${ZIP_DIR}/*")
|
|
|
|
set(ZIP_FILES_TXT "")
|
|
set(ZIP_FILES_DEP "")
|
|
foreach (ZIP_FILE ${ZIP_FILES})
|
|
file(RELATIVE_PATH REL_PATH "${in_dir}/${ZIP_DIR}" "${ZIP_FILE}")
|
|
set(ZIP_FILES_TXT "${ZIP_FILES_TXT}${REL_PATH}\n")
|
|
if (NOT IS_DIRECTORY ${ZIP_FILE})
|
|
list(APPEND ZIP_FILES_DEP ${ZIP_FILE})
|
|
endif ()
|
|
endforeach ()
|
|
file(WRITE "${TMP_FILE_DIR}/${ZIP_DIR}-filelist.txt" ${ZIP_FILES_TXT})
|
|
|
|
set(ZIP_NAME "${out_dir}/${ZIP_DIR}.zip")
|
|
add_custom_command(
|
|
OUTPUT ${ZIP_NAME}
|
|
DEPENDS ${ZIP_FILES_DEP}
|
|
COMMAND ${CMAKE_COMMAND} -E tar c ${ZIP_NAME} --format=zip --files-from="${TMP_FILE_DIR}/${ZIP_DIR}-filelist.txt"
|
|
WORKING_DIRECTORY "${in_dir}/${ZIP_DIR}"
|
|
)
|
|
list(APPEND ALL_ZIPS ${ZIP_NAME})
|
|
endforeach ()
|
|
|
|
add_custom_target(
|
|
zip_folder_${FROM_DIR_NAME} ALL
|
|
DEPENDS ${ALL_ZIPS}
|
|
)
|
|
set_property(TARGET zip_folder_${FROM_DIR_NAME} PROPERTY FOLDER "Scripts")
|
|
endfunction(recursive_zip_folder)
|
|
|
|
function(fast_copy FROM_DIR TO_DIR)
|
|
file(GLOB_RECURSE files "${FROM_DIR}/*")
|
|
get_filename_component(FROM_DIR_NAME ${FROM_DIR} NAME)
|
|
|
|
foreach (file IN LISTS files)
|
|
file(RELATIVE_PATH output_file ${FROM_DIR} ${file})
|
|
set(dest "${TO_DIR}/${output_file}")
|
|
|
|
add_custom_command(
|
|
COMMENT "Copying ${output_file}"
|
|
OUTPUT ${dest}
|
|
DEPENDS ${file}
|
|
COMMAND ${CMAKE_COMMAND} -E copy ${file} ${dest}
|
|
)
|
|
list(APPEND ALL_FILES ${dest})
|
|
endforeach ()
|
|
|
|
add_custom_target(
|
|
fast_copy_${FROM_DIR_NAME} ALL
|
|
DEPENDS ${ALL_FILES}
|
|
)
|
|
set_property(TARGET fast_copy_${FROM_DIR_NAME} PROPERTY FOLDER "Scripts")
|
|
endfunction()
|
|
|
|
function(extract_pot source_files_list)
|
|
set(FILELIST ${CMAKE_BINARY_DIR}/tmp/xgettext-filelist.txt)
|
|
set(ROR_POT "${CMAKE_SOURCE_DIR}/languages/ror.pot")
|
|
|
|
list(JOIN source_files_list "\n" source_files)
|
|
file(WRITE "${FILELIST}" "${source_files}")
|
|
|
|
add_custom_target(
|
|
extract_pot
|
|
COMMENT "Extract pot"
|
|
OUTPUT ${ROR_POT}
|
|
COMMAND xgettext -i -F -k_L -k_LC:1c,2 -c -o${ROR_POT} -f ${FILELIST}
|
|
WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
|
|
)
|
|
set_property(TARGET extract_pot PROPERTY FOLDER "Scripts")
|
|
endfunction()
|
|
|
|
function(compile_mo)
|
|
file(GLOB_RECURSE potfiles ${CMAKE_SOURCE_DIR}/languages/*/*.po CONFIGURE_DEPENDS)
|
|
|
|
foreach (file IN LISTS potfiles)
|
|
get_filename_component(dir ${file} DIRECTORY)
|
|
get_filename_component(filename ${file} NAME_WE)
|
|
get_filename_component(name "${dir}" NAME)
|
|
set(out "${dir}/${filename}.mo")
|
|
add_custom_command(
|
|
COMMENT "Compiling ${name}"
|
|
OUTPUT ${out}
|
|
DEPENDS ${file}
|
|
COMMAND msgfmt -o${out} ${file}
|
|
WORKING_DIRECTORY ${dir}
|
|
)
|
|
list(APPEND MO_FILES ${out})
|
|
endforeach ()
|
|
|
|
add_custom_target(
|
|
compile_mo
|
|
DEPENDS ${MO_FILES}
|
|
)
|
|
set_property(TARGET compile_mo PROPERTY FOLDER "Scripts")
|
|
endfunction()
|
|
|
|
# Argument parser helper. This may look like magic, but it is pretty simple:
|
|
# - Call this at the top of a function
|
|
# - It takes three "list" arguments: `.`, `-` and `+`.
|
|
# - The `.` arguments specify the "option/boolean" values to parse out.
|
|
# - The `-` arguments specify the one-value arguments to parse out.
|
|
# - The `+` argumenst specify mult-value arguments to parse out.
|
|
# - Specify `-nocheck` to disable warning on unparse arguments.
|
|
# - Parse values are prefixed with `ARG`
|
|
#
|
|
# This macro makes use of some very horrible aspects of CMake macros:
|
|
# - Values appear the caller's scope, so no need to set(PARENT_SCOPE)
|
|
# - The ${${}ARGV} eldritch horror evaluates to the ARGV *OF THE CALLER*, while
|
|
# ${ARGV} evaluates to the macro's own ARGV value. This is because ${${}ARGV}
|
|
# inhibits macro argument substitution. It is painful, but it makes this magic
|
|
# work.
|
|
macro(better_parse_args)
|
|
cmake_parse_arguments(_ "-nocheck;-hardcheck" "" ".;-;+" "${ARGV}")
|
|
set(__arglist "${${}ARGV}")
|
|
better_parse_arglist("${__.}" "${__-}" "${__+}")
|
|
endmacro()
|
|
|
|
macro(better_parse_arglist opt args list_args)
|
|
cmake_parse_arguments(ARG "${opt}" "${args}" "${list_args}" "${__arglist}")
|
|
if (NOT __-nocheck)
|
|
foreach (arg IN LISTS ARG_UNPARSED_ARGUMENTS)
|
|
message(WARNING "Unknown argument: ${arg}")
|
|
endforeach ()
|
|
if (__-hardcheck AND NOT ("${ARG_UNPARSED_ARGUMENTS}" STREQUAL ""))
|
|
message(FATAL_ERROR "Unknown arguments provided.")
|
|
endif ()
|
|
endif ()
|
|
endmacro()
|
|
|
|
|
|
macro(lift_var)
|
|
foreach (varname IN ITEMS ${ARGN})
|
|
set("${varname}" "${${varname}}" PARENT_SCOPE)
|
|
endforeach ()
|
|
endmacro()
|
|
|
|
# Taken from wxWidgets
|
|
#
|
|
# cmd_option(<name> <desc> [default] [STRINGS strings])
|
|
# The default is ON if third parameter isn't specified
|
|
function(cmd_option name desc)
|
|
cmake_parse_arguments(OPTION "" "" "STRINGS" ${ARGN})
|
|
|
|
if (ARGC EQUAL 2)
|
|
if (OPTION_STRINGS)
|
|
list(GET OPTION_STRINGS 1 default)
|
|
else ()
|
|
set(default ON)
|
|
endif ()
|
|
else ()
|
|
set(default ${OPTION_UNPARSED_ARGUMENTS})
|
|
endif ()
|
|
|
|
if (OPTION_STRINGS)
|
|
set(cache_type STRING)
|
|
else ()
|
|
set(cache_type BOOL)
|
|
endif ()
|
|
|
|
set(${name} "${default}" CACHE ${cache_type} "${desc}")
|
|
if (OPTION_STRINGS)
|
|
set_property(CACHE ${name} PROPERTY STRINGS ${OPTION_STRINGS})
|
|
|
|
# Check valid value
|
|
set(value_is_valid FALSE)
|
|
set(avail_values)
|
|
foreach (opt ${OPTION_STRINGS})
|
|
if (${name} STREQUAL opt)
|
|
set(value_is_valid TRUE)
|
|
break()
|
|
endif ()
|
|
string(APPEND avail_values " ${opt}")
|
|
endforeach ()
|
|
if (NOT value_is_valid)
|
|
message(FATAL_ERROR "Invalid value \"${${name}}\" for option ${name}. Valid values are: ${avail_values}")
|
|
endif ()
|
|
endif ()
|
|
|
|
set(${name} "${${name}}" PARENT_SCOPE)
|
|
endfunction()
|