mirror of
https://github.com/Kitware/CMake.git
synced 2026-04-22 14:23:10 -05:00
Brad King
ecb0f3af55
This creates a new mode of the foreach command which allows precise iteration even over empty elements. This mode may be safely extended with more keyword arguments in the future. The cost now is possibly breaking scripts that iterate over a list of items beginning with 'IN', but there is no other way to extend the syntax in a readable way.
239 lines
8.9 KiB
CMake
239 lines
8.9 KiB
CMake
cmake_minimum_required (VERSION 2.6)
|
|
PROJECT(StringFileTest)
|
|
INCLUDE_DIRECTORIES(${StringFileTest_BINARY_DIR})
|
|
|
|
# Read file test
|
|
FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in" infile)
|
|
|
|
# FILE(STRINGS) test
|
|
FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in" infile_strings
|
|
LIMIT_COUNT 1 LIMIT_INPUT 1024 LIMIT_OUTPUT 1024
|
|
LENGTH_MINIMUM 10 LENGTH_MAXIMUM 23 REGEX include NEWLINE_CONSUME)
|
|
SET(infile_strings_goal "#include \"includefile\"\n")
|
|
IF("${infile_strings}" STREQUAL "${infile_strings_goal}")
|
|
MESSAGE("FILE(STRINGS) correctly read [${infile_strings}]")
|
|
ELSE("${infile_strings}" STREQUAL "${infile_strings_goal}")
|
|
MESSAGE(SEND_ERROR
|
|
"FILE(STRINGS) incorrectly read [${infile_strings}]")
|
|
ENDIF("${infile_strings}" STREQUAL "${infile_strings_goal}")
|
|
|
|
# test reading a file and getting its binary data as hex string
|
|
FILE(READ "${CMAKE_CURRENT_SOURCE_DIR}/main.srec" infilehex LIMIT 4 HEX)
|
|
IF(NOT "${infilehex}" STREQUAL "53313036")
|
|
MESSAGE(SEND_ERROR
|
|
"FILE(READ ... HEX) error, read: \"${infilehex}\", expected \"53313036\"")
|
|
ENDIF(NOT "${infilehex}" STREQUAL "53313036")
|
|
|
|
|
|
# test that FILE(STRINGS) also work with Intel hex and Motorola S-record files
|
|
# this file has been created with "sdcc main.c"
|
|
FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/main.ihx" infile_strings REGEX INFO)
|
|
SET(infile_strings_goal "INFO:compiler\\[SDCC-HEX\\]")
|
|
IF("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
MESSAGE("FILE(STRINGS) correctly read from hex file [${infile_strings}]")
|
|
ELSE("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
MESSAGE(SEND_ERROR
|
|
"FILE(STRINGS) incorrectly read from hex file [${infile_strings}]")
|
|
ENDIF("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
|
|
# this file has been created with "sdcc main.c --out-fmt-s19"
|
|
FILE(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/main.srec" infile_strings REGEX INFO)
|
|
SET(infile_strings_goal "INFO:compiler\\[SDCC-SREC\\]")
|
|
IF("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
MESSAGE("FILE(STRINGS) correctly read from srec file [${infile_strings}]")
|
|
ELSE("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
MESSAGE(SEND_ERROR
|
|
"FILE(STRINGS) incorrectly read from srec file [${infile_strings}]")
|
|
ENDIF("${infile_strings}" MATCHES "${infile_strings_goal}")
|
|
|
|
# String test
|
|
STRING(REGEX MATCH "[cC][mM][aA][kK][eE]" rmvar "CMake is great")
|
|
STRING(REGEX MATCHALL "[cC][mM][aA][kK][eE]" rmallvar "CMake is better than cmake or CMake")
|
|
STRING(REGEX REPLACE "[Aa][uU][tT][oO]([cC][oO][nN][fF]|[mM][aA][kK][eE])"
|
|
"CMake" rrepvar "People should use Autoconf and Automake")
|
|
STRING(COMPARE EQUAL "CMake" "Autoconf" nceqvar)
|
|
STRING(COMPARE EQUAL "CMake" "CMake" ceqvar)
|
|
STRING(COMPARE NOTEQUAL "CMake" "Autoconf" cneqvar)
|
|
STRING(COMPARE NOTEQUAL "CMake" "CMake" ncneqvar)
|
|
STRING(COMPARE LESS "before" "after" nclvar)
|
|
STRING(COMPARE LESS "max" "min" clvar)
|
|
STRING(COMPARE GREATER "before" "after" cgvar)
|
|
STRING(COMPARE GREATER "max" "min" ncgvar)
|
|
STRING(ASCII 67 109 97 107 101 savar)
|
|
STRING(TOUPPER "CMake" tuvar)
|
|
STRING(TOLOWER "CMake" tlvar)
|
|
STRING(REPLACE "Autoconf" "CMake" repvar "People should use Autoconf")
|
|
|
|
IF("abc" STREQUAL "xyz")
|
|
MESSAGE(SEND_ERROR "Problem with the IF(STREQUAL), \"abc\" and \"xyz\" considered equal")
|
|
ENDIF("abc" STREQUAL "xyz")
|
|
|
|
IF("CMake is cool" MATCHES "(CMake) (is).+")
|
|
IF(NOT "${CMAKE_MATCH_0}" STREQUAL "CMake is cool")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_0 wrong: \"${CMAKE_MATCH_0}\", expected \"CMake is cool\"")
|
|
ENDIF(NOT "${CMAKE_MATCH_0}" STREQUAL "CMake is cool")
|
|
IF(NOT "${CMAKE_MATCH_1}" STREQUAL "CMake")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_1 wrong: \"${CMAKE_MATCH_1}\", expected \"CMake\"")
|
|
ENDIF(NOT "${CMAKE_MATCH_1}" STREQUAL "CMake")
|
|
IF(NOT "${CMAKE_MATCH_2}" STREQUAL "is")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_2 wrong: \"${CMAKE_MATCH_2}\", expected \"is\"")
|
|
ENDIF(NOT "${CMAKE_MATCH_2}" STREQUAL "is")
|
|
ELSE("CMake is cool" MATCHES "(CMake) (is).+")
|
|
MESSAGE(SEND_ERROR "Problem with the IF(MATCHES), no match found")
|
|
ENDIF("CMake is cool" MATCHES "(CMake) (is).+")
|
|
|
|
STRING(REGEX MATCH "(People).+CMake" matchResultVar "People should use CMake")
|
|
IF(NOT "${matchResultVar}" STREQUAL "People should use CMake")
|
|
MESSAGE(SEND_ERROR "STRING(REGEX MATCH) problem: \"${matchResultVar}\", expected \"People should use CMake\"")
|
|
ENDIF(NOT "${matchResultVar}" STREQUAL "People should use CMake")
|
|
IF(NOT "${CMAKE_MATCH_0}" STREQUAL "People should use CMake")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_0 wrong: \"${CMAKE_MATCH_0}\", expected \"People should use CMake\"")
|
|
ENDIF(NOT "${CMAKE_MATCH_0}" STREQUAL "People should use CMake")
|
|
IF(NOT "${CMAKE_MATCH_1}" STREQUAL "People")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_1 wrong: \"${CMAKE_MATCH_1}\", expected \"People\"")
|
|
ENDIF(NOT "${CMAKE_MATCH_1}" STREQUAL "People")
|
|
IF(NOT "${CMAKE_MATCH_2}" STREQUAL "")
|
|
MESSAGE(SEND_ERROR "CMAKE_MATCH_2 wrong: \"${CMAKE_MATCH_2}\", expected empty string")
|
|
ENDIF(NOT "${CMAKE_MATCH_2}" STREQUAL "")
|
|
|
|
|
|
STRING(STRIP "
|
|
ST1
|
|
" ST1)
|
|
STRING(STRIP "ST2 " ST2)
|
|
STRING(STRIP " ST3" ST3)
|
|
|
|
FOREACH(var ST1 ST2 ST3)
|
|
IF("${var}" STREQUAL "${${var}}")
|
|
MESSAGE("[${var}] == [${${var}}]")
|
|
ELSE("${var}" STREQUAL "${${var}}")
|
|
MESSAGE(SEND_ERROR "Problem with the STRIP command for ${var}: [${${var}}]")
|
|
ENDIF("${var}" STREQUAL "${${var}}")
|
|
ENDFOREACH(var)
|
|
|
|
STRING(SUBSTRING "People should use Autoconf" 7 10 substringres)
|
|
SET(substringres "Everybody ${substringres} CMake")
|
|
|
|
STRING(LENGTH ${substringres} lengthres)
|
|
|
|
FILE(RELATIVE_PATH relpath "/usr/local/bin" "/usr/X11R6/bin/xnest")
|
|
|
|
# Escaping test
|
|
SET(var "\\ \" \ \t \n \r \# \( \) \0")
|
|
MESSAGE("Output: [${var}]")
|
|
SET(var \\ \" \ \t \n \r \# \( \) \0)
|
|
MESSAGE("Output: [${var}]")
|
|
|
|
# Make-style unquoted argument test
|
|
SET(var $(VAR1)$(VAR2)/$(VAR3))
|
|
MESSAGE("Output: [${var}]")
|
|
STRING(COMPARE EQUAL "${var}" "$(VAR1)$(VAR2)/$(VAR3)" result)
|
|
IF(NOT result)
|
|
MESSAGE(SEND_ERROR "Unquoted $(VAR) syntax is broken.")
|
|
ENDIF(NOT result)
|
|
|
|
# Obscure environment variable name
|
|
SET("ENV{x+(y)}" "Obscure environment variable value")
|
|
MESSAGE("Output: [$ENV{x+(y)}]")
|
|
IF(NOT "$ENV{x+(y)}" STREQUAL "Obscure environment variable value")
|
|
MESSAGE(SEND_ERROR "Environment variable \"ENV{x+(y)}\" does not work.")
|
|
ENDIF()
|
|
|
|
# Make directories test
|
|
FILE(MAKE_DIRECTORY
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Includes"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Directory1"
|
|
"${CMAKE_CURRENT_BINARY_DIR}/Directory2"
|
|
)
|
|
|
|
# Write results to the file (test write file)
|
|
SET(file "${CMAKE_CURRENT_BINARY_DIR}/Includes/Values.h")
|
|
FILE(WRITE "${file}" "/* this file is generated */\n")
|
|
FOREACH(var
|
|
rmvar
|
|
rmallvar
|
|
rrepvar
|
|
repvar
|
|
relpath
|
|
substringres
|
|
lengthres
|
|
nceqvar
|
|
ceqvar
|
|
cneqvar
|
|
ncneqvar
|
|
nclvar
|
|
clvar
|
|
cgvar
|
|
ncgvar
|
|
savar
|
|
tuvar
|
|
tlvar)
|
|
FILE(APPEND "${file}" "#define ${var} \"${${var}}\"\n")
|
|
ENDFOREACH(var)
|
|
|
|
# Verify that the file was created recently.
|
|
IF(NOT "${file}" IS_NEWER_THAN "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in")
|
|
MESSAGE(FATAL_ERROR "IF(FILE_IS_NEWER) does not seem to work.")
|
|
ENDIF(NOT "${file}" IS_NEWER_THAN "${CMAKE_CURRENT_SOURCE_DIR}/InputFile.h.in")
|
|
|
|
# Test configuration of the string
|
|
SET(TEST_DEFINED 123)
|
|
SET(TEST_NOT_DEFINED)
|
|
STRING(CONFIGURE "${infile}" infile+-/out @ONLY)
|
|
SET(infile "${infile+-/out}")
|
|
|
|
# Write include file to a file
|
|
STRING(REGEX REPLACE "includefile" "${file}" outfile "${infile}")
|
|
FILE(WRITE "${CMAKE_CURRENT_BINARY_DIR}/OutputFile.h" "${outfile}")
|
|
|
|
# Test file glob
|
|
FILE(GLOB_RECURSE src_files "${CMAKE_CURRENT_SOURCE_DIR}/*")
|
|
MESSAGE("Files in ${CMAKE_CURRENT_SOURCE_DIR} are ${src_files}")
|
|
SET(expr "${CMAKE_CURRENT_SOURCE_DIR}/[sS][!a-su-zA-Z0-9][^a-qs-zA-Z0-9]ing?ile*.cxx")
|
|
MESSAGE("Glob expression is [${expr}].")
|
|
FILE(GLOB src_files "${expr}")
|
|
MESSAGE("Globbed files [${src_files}].")
|
|
ADD_EXECUTABLE(StringFileTest ${src_files})
|
|
|
|
SET(expr "${CMAKE_CURRENT_SOURCE_DIR}/../*.cxx")
|
|
FILE(GLOB_RECURSE rel_src_files RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}/.." "${expr}")
|
|
MESSAGE("Globbed files [${rel_src_files}].")
|
|
|
|
# Test FOREACH range
|
|
MESSAGE("Cheack if FOREACH with RANGE works")
|
|
MACRO(TEST_RANGE ARGS CHECK)
|
|
SET(r)
|
|
FOREACH(a RANGE ${ARGS})
|
|
SET(r ${r} ${a})
|
|
ENDFOREACH(a)
|
|
MESSAGE("FOREACH with RANGE ${ARGS} produces ${r}")
|
|
IF("x${r}x" MATCHES "^x${CHECK}x$")
|
|
ELSE("x${r}x" MATCHES "^x${CHECK}x$")
|
|
MESSAGE(SEND_ERROR "The range resulted in: ${r} should be ${CHECK}")
|
|
ENDIF("x${r}x" MATCHES "^x${CHECK}x$")
|
|
ENDMACRO(TEST_RANGE)
|
|
TEST_RANGE("5" "0;1;2;3;4;5")
|
|
TEST_RANGE("3;5" "3;4;5")
|
|
TEST_RANGE("5;3" "5;4;3")
|
|
TEST_RANGE("3;10;2" "3;5;7;9")
|
|
TEST_RANGE("10;0;-3" "10;7;4;1")
|
|
|
|
# Test FOREACH IN signature
|
|
set(list1 "" a "")
|
|
set(list2 a "" b)
|
|
set(var_)
|
|
set(var_a)
|
|
set(var_b)
|
|
foreach(item IN LISTS list1 list2 ITEMS "" a "")
|
|
set(var_${item} "${var_${item}}x")
|
|
endforeach(item)
|
|
if(NOT "${var_}" STREQUAL "xxxxx")
|
|
message(FATAL_ERROR "count incorrect for \"\": [${var_}]")
|
|
endif()
|
|
if(NOT "${var_a}" STREQUAL "xxx")
|
|
message(FATAL_ERROR "count incorrect for \"a\": [${var_a}]")
|
|
endif()
|
|
if(NOT "${var_b}" STREQUAL "x")
|
|
message(FATAL_ERROR "count incorrect \"b\": [${var_b}]")
|
|
endif()
|