string

Операции со строками.

Краткое описание

Search and Replace
  string(FIND <string> <substring> <out-var> [...])
  string(REPLACE <match-string> <replace-string> <out-var> <input>...)
  string(REGEX MATCH <match-regex> <out-var> <input>...)
  string(REGEX MATCHALL <match-regex> <out-var> <input>...)
  string(REGEX REPLACE <match-regex> <replace-expr> <out-var> <input>...)

Manipulation
  string(APPEND <string-var> [<input>...])
  string(PREPEND <string-var> [<input>...])
  string(CONCAT <out-var> [<input>...])
  string(JOIN <glue> <out-var> [<input>...])
  string(TOLOWER <string> <out-var>)
  string(TOUPPER <string> <out-var>)
  string(LENGTH <string> <out-var>)
  string(SUBSTRING <string> <begin> <length> <out-var>)
  string(STRIP <string> <out-var>)
  string(GENEX_STRIP <string> <out-var>)
  string(REPEAT <string> <count> <out-var>)

Comparison
  string(COMPARE <op> <string1> <string2> <out-var>)

Hashing
  string(<HASH> <out-var> <input>)

Generation
  string(ASCII <number>... <out-var>)
  string(HEX <string> <out-var>)
  string(CONFIGURE <string> <out-var> [...])
  string(MAKE_C_IDENTIFIER <string> <out-var>)
  string(RANDOM [<option>...] <out-var>)
  string(TIMESTAMP <out-var> [<format string>] [UTC])
  string(UUID <out-var> ...)

Поиск и замена

Поиск и замена обычными строками

string(FIND <string> <substring> <output_variable> [REVERSE])

Возвращает позицию, в которой указанная <substring> найдена в предоставленной <string>. Если использовался флаг REVERSE, команда будет искать позицию последнего вхождения указанной <substring>. Если <substring> не найдена, возвращается позиция -1.

Подкоманда string(FIND) обрабатывает все строки как содержащие только символы ASCII. Индекс, хранящийся в <output_variable>, также будет учитываться в байтах, поэтому строки, содержащие многобайтовые символы, могут привести к неожиданным результатам.

string(REPLACE <match_string>
       <replace_string> <output_variable>
       <input> [<input>...])

Заменяет все вхождения <match_string> в <input> на <replace_string> и сохраняет результат в <output_variable>.

Поиск и замена с использованием регулярных выражений

string(REGEX MATCH <regular_expression>
       <output_variable> <input> [<input>...])

Сопоставляет <regular_expression> один раз и сохраняет совпадение в <output_variable>. Все аргументы <input> конкатенируются перед сопоставлением. Регулярные выражения описаны в разделе ниже.

string(REGEX MATCHALL <regular_expression>
       <output_variable> <input> [<input>...])

Сопоставляет <regular_expression> как можно больше раз и сохраняет совпадения в <output_variable> в виде списка. Все аргументы <input> конкатенируются перед сопоставлением.

string(REGEX REPLACE <regular_expression>
       <replacement_expression> <output_variable>
       <input> [<input>...])

Сопоставляет <regular_expression> как можно больше раз и заменяет совпадение в выводе на <replacement_expression>. Все аргументы <input> конкатенируются перед сопоставлением.

В <replacement_expression> можно ссылаться на скобочные подвыражения совпадения, используя \1, \2, …, \9. Обратите внимание, что для получения обратной косой черты через обработку аргументов в коде CMake требуется две обратные косые черты (\\1).

Спецификация регулярных выражений

В регулярных выражениях следующие символы имеют специальное значение:

^

Сопоставляет начало входных данных

$

Сопоставляет конец входных данных

.

Сопоставляет любой одиночный символ

\<char>

Сопоставляет одиночный символ, указанный в <char>. Используйте это для сопоставления специальных символов регулярных выражений, например \. для буквальной . или \\ для буквальной обратной косой черты \. Экранирование неспециального символа не обязательно, но разрешено, например, \a сопоставляет a.

[ ]

Сопоставляет любой символ(ы) внутри скобок

[^ ]

Сопоставляет любой символ(ы), не находящиеся внутри скобок

-

Внутри скобок, определяет включительный диапазон между символами по обе стороны, например, [a-f] — это [abcdef]. Чтобы сопоставить буквенный - с использованием скобок, сделайте его первым или последним символом, например, [+*/-] сопоставляет базовые математические операторы.

*

Сопоставляет предшествующий шаблон ноль или более раз

+

Сопоставляет предшествующий шаблон один или более раз

?

Сопоставляет предшествующий шаблон ноль или один раз

|

Сопоставляет шаблон по обе стороны от |

()

Сохраняет сопоставленное подвыражение, которое можно использовать в операции REGEX REPLACE. Кроме того, оно сохраняется всеми командами, связанными с регулярными выражениями, включая, например, if(MATCHES), в переменных CMAKE_MATCH_<n> для <n> 0..9.

*, + и ? имеют более высокий приоритет, чем конкатенация. | имеет более низкий приоритет, чем конкатенация. Это означает, что регулярное выражение ^ab+d$ сопоставляет abbd, но не ababd, и регулярное выражение ^(ab|cd)$ сопоставляет ab, но не abd.

Язык CMake Последовательности экранирования, такие как \t, \r, \n, и \\, могут использоваться для построения буквальных табуляций, возвратов каретки, новых строк и обратных косых черт (соответственно) для передачи в регулярное выражение. Например:

• Процитированный аргумент "[ \t\r\n]" указывает на регулярное выражение, которое сопоставляет любой одиночный символ пробела.
• Процитированный аргумент "[/\\]" указывает на регулярное выражение, которое сопоставляет одиночный прямой или обратный слэш / \.
• Процитированный аргумент "[A-Za-z0-9_]" указывает на регулярное выражение, которое сопоставляет любой одиночный символ слова в локали C.
• Процитированный аргумент "\\(\\a\\+b\\)" указывает на регулярное выражение, которое сопоставляет точную строку (a+b). Каждый \\ разбирается в процитированном аргументе как просто \, поэтому само регулярное выражение на самом деле \(\a\+\b\). Это можно альтернативно указать в Аргументе в скобках без необходимости экранирования обратных косых черт, например [[\(\a\+\b\)]].

Манипуляции

string(APPEND <string_variable> [<input>...])

Добавляет все аргументы <input> к строке.

string(PREPEND <string_variable> [<input>...])

Добавляет все аргументы <input> в начало строки.

string(CONCAT <output_variable> [<input>...])

Конкатенирует все аргументы <input> вместе и сохраняет результат в указанной <output_variable>.

string(JOIN <glue> <output_variable> [<input>...])

Объединяет все аргументы <input> с использованием строки <glue> и сохраняет результат в указанной <output_variable>.

Для объединения элементов списка используйте оператор JOIN из команды list(). Это позволяет элементам содержать специальные символы, такие как ;.

string(TOLOWER <string> <output_variable>)

Преобразует <string> в строчные буквы.

string(TOUPPER <string> <output_variable>)

Преобразует <string> в заглавные буквы.

string(LENGTH <string> <output_variable>)

Сохраняет в <output_variable> длину заданной строки в байтах. Обратите внимание, что это означает, что если <string> содержит многобайтовые символы, результат, сохраненный в <output_variable>, не будет количеством символов.

string(SUBSTRING <string> <begin> <length> <output_variable>)

Сохраняет в <output_variable> подстроку заданной <string>. Если <length> равно -1, возвращается остаток строки, начинающийся с <begin>. Если <string> короче <length>, вместо этого используется конец строки.

И <begin>, и <length> подсчитываются в байтах, поэтому необходимо проявлять осторожность, если <string> может содержать многобайтовые символы.

string(STRIP <string> <output_variable>)

Сохраняет в <output_variable> подстроку заданной <string>, удалив ведущие и хвостовые пробелы.

string(GENEX_STRIP <string> <output_variable>)

Удаляет любые generator expressions из входных данных <string> и сохраняет результат в <output_variable>.

string(REPEAT <string> <count> <output_variable>)

Создаёт выходную строку как входящую строку <string> повторяемую <count> раз.

Сравнение

string(COMPARE LESS <string1> <string2> <output_variable>)
string(COMPARE GREATER <string1> <string2> <output_variable>)
string(COMPARE EQUAL <string1> <string2> <output_variable>)
string(COMPARE NOTEQUAL <string1> <string2> <output_variable>)
string(COMPARE LESS_EQUAL <string1> <string2> <output_variable>)
string(COMPARE GREATER_EQUAL <string1> <string2> <output_variable>)

Сравнивает строки и сохраняет истину или ложь в <output_variable>.

Хеширование

string(<HASH> <output_variable> <input>)

Вычисляет криптографический хеш строки <input>. Поддерживаемые алгоритмы хеширования:

MD5

Алгоритм дайджеста сообщений 5, RFC 1321.

SHA1

Алгоритм безопасного хеширования США 1, RFC 3174.

SHA224

Алгоритмы безопасного хеширования США, RFC 4634.

SHA256

Алгоритмы безопасного хеширования США, RFC 4634.

SHA384

Алгоритмы безопасного хеширования США, RFC 4634.

SHA512

Алгоритмы безопасного хеширования США, RFC 4634.

SHA3_224

Keccak SHA-3.

SHA3_256

Keccak SHA-3.

SHA3_384

Keccak SHA-3.

SHA3_512

Keccak SHA-3.

Генерация

string(ASCII <number> [<number> ...] <output_variable>)

Преобразует все числа в соответствующие символы ASCII.

string(HEX <string> <output_variable>)

Преобразует каждый байт в входных данных <string> в его шестнадцатеричное представление и сохраняет конкатенированные шестнадцатеричные цифры в <output_variable>.

Преобразует <string> как configure_file() преобразует файл.

string(MAKE_C_IDENTIFIER <string> <output_variable>)

Преобразует каждый неалфавитно-цифровой символ во входных данных <string> в символ подчеркивания и сохраняет результат в <output_variable>.

string(RANDOM [LENGTH <length>] [ALPHABET <alphabet>]
       [RANDOM_SEED <seed>] <output_variable>)

Возвращает случайную строку заданной <length> длины, состоящую из символов из заданного <alphabet> . Длина по умолчанию составляет 5 символов, а алфавит по умолчанию — все цифры и заглавные и строчные буквы. Если указан целое число RANDOM_SEED, его значение будет использовано для инициализации генератора случайных чисел.

string(TIMESTAMP <output_variable> [<format_string>] [UTC])

Запишите строковое представление текущей даты и/или времени в <output_variable>.

Если команда не может получить отметку времени, <output_variable> будет установлено в пустую строку "".

Необязательный флаг UTC запрашивает представление текущей даты/времени в формате Coordinated Universal Time (UTC) вместо локального времени.

Необязательный <format_string> может содержать следующие спецификаторы формата:

%%        A literal percent sign (%).
%d        The day of the current month (01-31).
%H        The hour on a 24-hour clock (00-23).
%I        The hour on a 12-hour clock (01-12).
%j        The day of the current year (001-366).
%m        The month of the current year (01-12).
%b        Abbreviated month name (e.g. Oct).
%B        Full month name (e.g. October).
%M        The minute of the current hour (00-59).
%s        Seconds since midnight (UTC) 1-Jan-1970 (UNIX time).
%S        The second of the current minute.
          60 represents a leap second. (00-60)
%U        The week number of the current year (00-53).
%w        The day of the current week. 0 is Sunday. (0-6)
%a        Abbreviated weekday name (e.g. Fri).
%A        Full weekday name (e.g. Friday).
%y        The last two digits of the current year (00-99)
%Y        The current year.

Неизвестные спецификаторы формата будут проигнорированы и скопированы в выходные данные как есть.

Если явное указание <format_string> не задано, оно будет установлено по умолчанию в:

%Y-%m-%dT%H:%M:%S    for local time.
%Y-%m-%dT%H:%M:%SZ   for UTC.

string(UUID <output_variable> NAMESPACE <namespace> NAME <name>
       TYPE <MD5|SHA1> [UPPER])

Создайте универсальный уникальный идентификатор (также известный как GUID) в соответствии с RFC4122, основанный на хэше объединённых значений <namespace> (который сам должен быть корректным UUID) и <name>. Алгоритм хеширования может быть MD5 (UUID версии 3) или SHA1 (UUID версии 5). UUID имеет формат xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx, где каждый x представляет собой строчную шестнадцатеричную цифру. При необходимости запрос на использование верхнего регистра может быть задан с помощью необязательного флага UPPER.