blob: 7321f4cbe3083752aced4f28f564deec61dfa8c9 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
|
# - Collection of String utility macros.
# Defines the following macros:
# STRING_TRIM(var str [NOUNQUOTE])
# - Trim a string by removing the leading and trailing spaces,
# just like STRING(STRIP ...) in CMake 2.6 and later.
# This macro is needed as CMake 2.4 does not support STRING(STRIP ..)
# This macro also remove quote and double quote marks around the string,
# unless NOUNQUOTE is defined.
# * Parameters:
# + var: A variable that stores the result.
# + str: A string.
# + NOUNQUOTE: (Optional) do not remove the double quote mark around the string.
#
# STRING_UNQUOTE(var str)
# - Remove double quote marks and quote marks around a string.
# If the string is not quoted, then it returns an empty string.
# * Parameters:
# + var: A variable that stores the result.
# + str: A string.
#
# STRING_JOIN(var delimiter str_list [str...])
# - Concatenate strings, with delimiter inserted between strings.
# * Parameters:
# + var: A variable that stores the result.
# + str_list: A list of string.
# + str: (Optional) more string to be join.
#
# STRING_SPLIT(var delimiter str [NOESCAPE_SEMICOLON])
# - Split a string into a list using a delimiter, which can be in 1 or more
# characters long.
# * Parameters:
# + var: A variable that stores the result.
# + delimiter: To separate a string.
# + str: A string.
# + NOESCAPE_SEMICOLON: (Optional) Do not escape semicolons.
#
IF(NOT DEFINED _MANAGE_STRING_CMAKE_)
SET(_MANAGE_STRING_CMAKE_ "DEFINED")
MACRO(STRING_TRIM var str)
SET(${var} "")
IF (NOT "${ARGN}" STREQUAL "NOUNQUOTE")
# Need not trim a quoted string.
STRING_UNQUOTE(_var "${str}")
IF(NOT _var STREQUAL "")
# String is quoted
SET(${var} "${_var}")
ENDIF(NOT _var STREQUAL "")
ENDIF(NOT "${ARGN}" STREQUAL "NOUNQUOTE")
IF(${var} STREQUAL "")
SET(_var_1 "${str}")
STRING(REGEX REPLACE "^[ \t\r\n]+" "" _var_2 "${str}" )
STRING(REGEX REPLACE "[ \t\r\n]+$" "" _var_3 "${_var_2}" )
SET(${var} "${_var_3}")
ENDIF(${var} STREQUAL "")
ENDMACRO(STRING_TRIM var str)
# Internal macro
# Variable cannot be escaped here, as variable is already substituted
# at the time it passes to this macro.
MACRO(STRING_ESCAPE var str)
# ';' and '\' are tricky, need to be encoded.
# '#' => '#H'
# '\' => '#B'
# ';' => '#S'
SET(_NOESCAPE_SEMICOLON "")
SET(_NOESCAPE_HASH "")
FOREACH(_arg ${ARGN})
IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
ELSEIF(${_arg} STREQUAL "NOESCAPE_HASH")
SET(_NOESCAPE_HASH "NOESCAPE_HASH")
ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
ENDFOREACH(_arg)
IF(_NOESCAPE_HASH STREQUAL "")
STRING(REGEX REPLACE "#" "#H" _ret "${str}")
ELSE(_NOESCAPE_HASH STREQUAL "")
SET(_ret "${str}")
ENDIF(_NOESCAPE_HASH STREQUAL "")
STRING(REGEX REPLACE "\\\\" "#B" _ret "${_ret}")
IF(_NOESCAPE_SEMICOLON STREQUAL "")
STRING(REGEX REPLACE ";" "#S" _ret "${_ret}")
ENDIF(_NOESCAPE_SEMICOLON STREQUAL "")
SET(${var} "${_ret}")
ENDMACRO(STRING_ESCAPE var str)
MACRO(STRING_UNESCAPE var str)
# '#B' => '\'
# '#H' => '#'
# '#D' => '$'
# '#S' => ';'
SET(_ESCAPE_VARIABLE "")
SET(_NOESCAPE_SEMICOLON "")
SET(_ret "${str}")
FOREACH(_arg ${ARGN})
IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
ELSEIF(${_arg} STREQUAL "ESCAPE_VARIABLE")
SET(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
STRING(REGEX REPLACE "#D" "$" _ret "${_ret}")
ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
ENDFOREACH(_arg)
STRING(REGEX REPLACE "#B" "\\\\" _ret "${_ret}")
IF(_NOESCAPE_SEMICOLON STREQUAL "")
# ';' => '#S'
STRING(REGEX REPLACE "#S" "\\\\;" _ret "${_ret}")
ELSE(_NOESCAPE_SEMICOLON STREQUAL "")
STRING(REGEX REPLACE "#S" ";" _ret "${_ret}")
ENDIF(_NOESCAPE_SEMICOLON STREQUAL "")
IF(NOT _ESCAPE_VARIABLE STREQUAL "")
# '#D' => '$'
STRING(REGEX REPLACE "#D" "$" _ret "${_ret}")
ENDIF(NOT _ESCAPE_VARIABLE STREQUAL "")
STRING(REGEX REPLACE "#H" "#" _ret "${_ret}")
SET(${var} "${_ret}")
ENDMACRO(STRING_UNESCAPE var str)
MACRO(STRING_UNQUOTE var str)
STRING_ESCAPE(_ret "${str}" ${ARGN})
IF(_ret MATCHES "^[ \t\r\n]+")
STRING(REGEX REPLACE "^[ \t\r\n]+" "" _ret "${_ret}")
ENDIF(_ret MATCHES "^[ \t\r\n]+")
IF(_ret MATCHES "^\"")
# Double quote
STRING(REGEX REPLACE "\"\(.*\)\"[ \t\r\n]*$" "\\1" _ret "${_ret}")
ELSEIF(_ret MATCHES "^'")
# Single quote
STRING(REGEX REPLACE "'\(.*\)'[ \t\r\n]*$" "\\1" _ret "${_ret}")
ELSE(_ret MATCHES "^\"")
SET(_ret "")
ENDIF(_ret MATCHES "^\"")
# Unencoding
STRING_UNESCAPE(${var} "${_ret}" ${ARGN})
ENDMACRO(STRING_UNQUOTE var str)
MACRO(STRING_JOIN var delimiter str_list)
SET(_ret "")
FOREACH(_str ${str_list})
IF(_ret STREQUAL "")
SET(_ret "${_str}")
ELSE(_ret STREQUAL "")
SET(_ret "${_ret}${delimiter}${_str}")
ENDIF(_ret STREQUAL "")
ENDFOREACH(_str ${str_list})
FOREACH(_str ${ARGN})
IF(_ret STREQUAL "")
SET(_ret "${_str}")
ELSE(_ret STREQUAL "")
SET(_ret "${_ret}${delimiter}${_str}")
ENDIF(_ret STREQUAL "")
ENDFOREACH(_str ${str_list})
SET(${var} "${_ret}")
ENDMACRO(STRING_JOIN var delimiter str_list)
MACRO(STRING_SPLIT var delimiter str)
SET(_max_tokens "")
SET(_NOESCAPE_SEMICOLON "")
SET(_ESCAPE_VARIABLE "")
FOREACH(_arg ${ARGN})
IF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
SET(_NOESCAPE_SEMICOLON "NOESCAPE_SEMICOLON")
ELSEIF(${_arg} STREQUAL "ESCAPE_VARIABLE")
SET(_ESCAPE_VARIABLE "ESCAPE_VARIABLE")
ELSE(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
SET(_max_tokens ${_arg})
ENDIF(${_arg} STREQUAL "NOESCAPE_SEMICOLON")
ENDFOREACH(_arg)
IF(NOT _max_tokens)
SET(_max_tokens -1)
ENDIF(NOT _max_tokens)
STRING_ESCAPE(_str "${str}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
STRING_ESCAPE(_delimiter "${delimiter}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
SET(_str_list "")
SET(_token_count 0)
STRING(LENGTH "${_delimiter}" _de_len)
WHILE(NOT _token_count EQUAL _max_tokens)
MATH(EXPR _token_count ${_token_count}+1)
IF(_token_count EQUAL _max_tokens)
# Last token, no need splitting
SET(_str_list ${_str_list} "${_str}")
ELSE(_token_count EQUAL _max_tokens)
# in case encoded characters are delimiters
STRING(LENGTH "${_str}" _str_len)
SET(_index 0)
SET(_token "")
SET(_str_remain "")
MATH(EXPR _str_end ${_str_len}-${_de_len}+1)
SET(_bound "k")
WHILE(_index LESS _str_end)
STRING(SUBSTRING "${_str}" ${_index} ${_de_len} _str_cursor)
IF(_str_cursor STREQUAL _delimiter)
# Get the token
STRING(SUBSTRING "${_str}" 0 ${_index} _token)
# Get the rest
MATH(EXPR _rest_index ${_index}+${_de_len})
MATH(EXPR _rest_len ${_str_len}-${_index}-${_de_len})
STRING(SUBSTRING "${_str}" ${_rest_index} ${_rest_len} _str_remain)
SET(_index ${_str_end})
ELSE(_str_cursor STREQUAL _delimiter)
MATH(EXPR _index ${_index}+1)
ENDIF(_str_cursor STREQUAL _delimiter)
ENDWHILE(_index LESS _str_end)
IF(_str_remain STREQUAL "")
# Meaning: end of string
LIST(APPEND _str_list "${_str}")
SET(_max_tokens ${_token_count})
ELSE(_str_remain STREQUAL "")
LIST(APPEND _str_list "${_token}")
SET(_str "${_str_remain}")
ENDIF(_str_remain STREQUAL "")
ENDIF(_token_count EQUAL _max_tokens)
ENDWHILE(NOT _token_count EQUAL _max_tokens)
# Unencoding
STRING_UNESCAPE(${var} "${_str_list}" ${_NOESCAPE_SEMICOLON} ${_ESCAPE_VARIABLE})
ENDMACRO(STRING_SPLIT var delimiter str)
ENDIF(NOT DEFINED _MANAGE_STRING_CMAKE_)
|
