Commit | Line | Data |
---|---|---|
d2fb8b41 | 1 | #include "util.h" |
b232e073 | 2 | #include "linux/string.h" |
ea5cc87c | 3 | |
d2fb8b41 HM |
4 | #define K 1024LL |
5 | /* | |
6 | * perf_atoll() | |
7 | * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB") | |
8 | * and return its numeric value | |
9 | */ | |
10 | s64 perf_atoll(const char *str) | |
11 | { | |
8ba7f6c2 AV |
12 | s64 length; |
13 | char *p; | |
14 | char c; | |
d2fb8b41 HM |
15 | |
16 | if (!isdigit(str[0])) | |
17 | goto out_err; | |
18 | ||
8ba7f6c2 AV |
19 | length = strtoll(str, &p, 10); |
20 | switch (c = *p++) { | |
21 | case 'b': case 'B': | |
22 | if (*p) | |
d2fb8b41 | 23 | goto out_err; |
94bdd5ed ACM |
24 | |
25 | __fallthrough; | |
8ba7f6c2 AV |
26 | case '\0': |
27 | return length; | |
28 | default: | |
29 | goto out_err; | |
30 | /* two-letter suffices */ | |
31 | case 'k': case 'K': | |
32 | length <<= 10; | |
d2fb8b41 | 33 | break; |
8ba7f6c2 AV |
34 | case 'm': case 'M': |
35 | length <<= 20; | |
d2fb8b41 | 36 | break; |
8ba7f6c2 AV |
37 | case 'g': case 'G': |
38 | length <<= 30; | |
d2fb8b41 | 39 | break; |
8ba7f6c2 AV |
40 | case 't': case 'T': |
41 | length <<= 40; | |
d2fb8b41 | 42 | break; |
d2fb8b41 | 43 | } |
8ba7f6c2 AV |
44 | /* we want the cases to match */ |
45 | if (islower(c)) { | |
46 | if (strcmp(p, "b") != 0) | |
47 | goto out_err; | |
48 | } else { | |
49 | if (strcmp(p, "B") != 0) | |
50 | goto out_err; | |
51 | } | |
52 | return length; | |
d2fb8b41 HM |
53 | |
54 | out_err: | |
8ba7f6c2 | 55 | return -1; |
d2fb8b41 | 56 | } |
e1c01d61 MH |
57 | |
58 | /* | |
59 | * Helper function for splitting a string into an argv-like array. | |
25985edc | 60 | * originally copied from lib/argv_split.c |
e1c01d61 MH |
61 | */ |
62 | static const char *skip_sep(const char *cp) | |
63 | { | |
64 | while (*cp && isspace(*cp)) | |
65 | cp++; | |
66 | ||
67 | return cp; | |
68 | } | |
69 | ||
70 | static const char *skip_arg(const char *cp) | |
71 | { | |
72 | while (*cp && !isspace(*cp)) | |
73 | cp++; | |
74 | ||
75 | return cp; | |
76 | } | |
77 | ||
78 | static int count_argc(const char *str) | |
79 | { | |
80 | int count = 0; | |
81 | ||
82 | while (*str) { | |
83 | str = skip_sep(str); | |
84 | if (*str) { | |
85 | count++; | |
86 | str = skip_arg(str); | |
87 | } | |
88 | } | |
89 | ||
90 | return count; | |
91 | } | |
92 | ||
93 | /** | |
94 | * argv_free - free an argv | |
95 | * @argv - the argument vector to be freed | |
96 | * | |
97 | * Frees an argv and the strings it points to. | |
98 | */ | |
99 | void argv_free(char **argv) | |
100 | { | |
101 | char **p; | |
102 | for (p = argv; *p; p++) | |
74cf249d | 103 | zfree(p); |
e1c01d61 MH |
104 | |
105 | free(argv); | |
106 | } | |
107 | ||
108 | /** | |
109 | * argv_split - split a string at whitespace, returning an argv | |
110 | * @str: the string to be split | |
111 | * @argcp: returned argument count | |
112 | * | |
113 | * Returns an array of pointers to strings which are split out from | |
114 | * @str. This is performed by strictly splitting on white-space; no | |
115 | * quote processing is performed. Multiple whitespace characters are | |
116 | * considered to be a single argument separator. The returned array | |
117 | * is always NULL-terminated. Returns NULL on memory allocation | |
118 | * failure. | |
119 | */ | |
120 | char **argv_split(const char *str, int *argcp) | |
121 | { | |
122 | int argc = count_argc(str); | |
123 | char **argv = zalloc(sizeof(*argv) * (argc+1)); | |
124 | char **argvp; | |
125 | ||
126 | if (argv == NULL) | |
127 | goto out; | |
128 | ||
129 | if (argcp) | |
130 | *argcp = argc; | |
131 | ||
132 | argvp = argv; | |
133 | ||
134 | while (*str) { | |
135 | str = skip_sep(str); | |
136 | ||
137 | if (*str) { | |
138 | const char *p = str; | |
139 | char *t; | |
140 | ||
141 | str = skip_arg(str); | |
142 | ||
143 | t = strndup(p, str-p); | |
144 | if (t == NULL) | |
145 | goto fail; | |
146 | *argvp++ = t; | |
147 | } | |
148 | } | |
149 | *argvp = NULL; | |
150 | ||
151 | out: | |
152 | return argv; | |
153 | ||
154 | fail: | |
155 | argv_free(argv); | |
156 | return NULL; | |
157 | } | |
bbbb521b | 158 | |
6964cd2c MH |
159 | /* Character class matching */ |
160 | static bool __match_charclass(const char *pat, char c, const char **npat) | |
161 | { | |
162 | bool complement = false, ret = true; | |
163 | ||
164 | if (*pat == '!') { | |
165 | complement = true; | |
166 | pat++; | |
167 | } | |
168 | if (*pat++ == c) /* First character is special */ | |
169 | goto end; | |
170 | ||
171 | while (*pat && *pat != ']') { /* Matching */ | |
172 | if (*pat == '-' && *(pat + 1) != ']') { /* Range */ | |
173 | if (*(pat - 1) <= c && c <= *(pat + 1)) | |
174 | goto end; | |
175 | if (*(pat - 1) > *(pat + 1)) | |
176 | goto error; | |
177 | pat += 2; | |
178 | } else if (*pat++ == c) | |
179 | goto end; | |
180 | } | |
181 | if (!*pat) | |
182 | goto error; | |
183 | ret = false; | |
184 | ||
185 | end: | |
186 | while (*pat && *pat != ']') /* Searching closing */ | |
187 | pat++; | |
188 | if (!*pat) | |
189 | goto error; | |
190 | *npat = pat + 1; | |
191 | return complement ? !ret : ret; | |
192 | ||
193 | error: | |
194 | return false; | |
195 | } | |
196 | ||
2a9c8c36 | 197 | /* Glob/lazy pattern matching */ |
38d14f0c AK |
198 | static bool __match_glob(const char *str, const char *pat, bool ignore_space, |
199 | bool case_ins) | |
bbbb521b MH |
200 | { |
201 | while (*str && *pat && *pat != '*') { | |
2a9c8c36 MH |
202 | if (ignore_space) { |
203 | /* Ignore spaces for lazy matching */ | |
204 | if (isspace(*str)) { | |
205 | str++; | |
206 | continue; | |
207 | } | |
208 | if (isspace(*pat)) { | |
209 | pat++; | |
210 | continue; | |
211 | } | |
212 | } | |
6964cd2c | 213 | if (*pat == '?') { /* Matches any single character */ |
bbbb521b MH |
214 | str++; |
215 | pat++; | |
6964cd2c MH |
216 | continue; |
217 | } else if (*pat == '[') /* Character classes/Ranges */ | |
218 | if (__match_charclass(pat + 1, *str, &pat)) { | |
219 | str++; | |
220 | continue; | |
221 | } else | |
bbbb521b | 222 | return false; |
6964cd2c MH |
223 | else if (*pat == '\\') /* Escaped char match as normal char */ |
224 | pat++; | |
38d14f0c AK |
225 | if (case_ins) { |
226 | if (tolower(*str) != tolower(*pat)) | |
227 | return false; | |
228 | } else if (*str != *pat) | |
6964cd2c | 229 | return false; |
38d14f0c AK |
230 | str++; |
231 | pat++; | |
bbbb521b MH |
232 | } |
233 | /* Check wild card */ | |
234 | if (*pat == '*') { | |
235 | while (*pat == '*') | |
236 | pat++; | |
237 | if (!*pat) /* Tail wild card matches all */ | |
238 | return true; | |
239 | while (*str) | |
38d14f0c | 240 | if (__match_glob(str++, pat, ignore_space, case_ins)) |
bbbb521b MH |
241 | return true; |
242 | } | |
243 | return !*str && !*pat; | |
244 | } | |
245 | ||
2a9c8c36 MH |
246 | /** |
247 | * strglobmatch - glob expression pattern matching | |
248 | * @str: the target string to match | |
249 | * @pat: the pattern string to match | |
250 | * | |
251 | * This returns true if the @str matches @pat. @pat can includes wildcards | |
252 | * ('*','?') and character classes ([CHARS], complementation and ranges are | |
253 | * also supported). Also, this supports escape character ('\') to use special | |
254 | * characters as normal character. | |
255 | * | |
256 | * Note: if @pat syntax is broken, this always returns false. | |
257 | */ | |
258 | bool strglobmatch(const char *str, const char *pat) | |
259 | { | |
38d14f0c AK |
260 | return __match_glob(str, pat, false, false); |
261 | } | |
262 | ||
263 | bool strglobmatch_nocase(const char *str, const char *pat) | |
264 | { | |
265 | return __match_glob(str, pat, false, true); | |
2a9c8c36 MH |
266 | } |
267 | ||
268 | /** | |
269 | * strlazymatch - matching pattern strings lazily with glob pattern | |
270 | * @str: the target string to match | |
271 | * @pat: the pattern string to match | |
272 | * | |
273 | * This is similar to strglobmatch, except this ignores spaces in | |
274 | * the target string. | |
275 | */ | |
276 | bool strlazymatch(const char *str, const char *pat) | |
277 | { | |
38d14f0c | 278 | return __match_glob(str, pat, true, false); |
2a9c8c36 | 279 | } |
bad03ae4 MH |
280 | |
281 | /** | |
282 | * strtailcmp - Compare the tail of two strings | |
283 | * @s1: 1st string to be compared | |
284 | * @s2: 2nd string to be compared | |
285 | * | |
286 | * Return 0 if whole of either string is same as another's tail part. | |
287 | */ | |
288 | int strtailcmp(const char *s1, const char *s2) | |
289 | { | |
290 | int i1 = strlen(s1); | |
291 | int i2 = strlen(s2); | |
292 | while (--i1 >= 0 && --i2 >= 0) { | |
293 | if (s1[i1] != s2[i2]) | |
294 | return s1[i1] - s2[i2]; | |
295 | } | |
296 | return 0; | |
297 | } | |
298 | ||
ea36c46b JO |
299 | /** |
300 | * strxfrchar - Locate and replace character in @s | |
301 | * @s: The string to be searched/changed. | |
302 | * @from: Source character to be replaced. | |
303 | * @to: Destination character. | |
304 | * | |
305 | * Return pointer to the changed string. | |
306 | */ | |
307 | char *strxfrchar(char *s, char from, char to) | |
308 | { | |
309 | char *p = s; | |
310 | ||
311 | while ((p = strchr(p, from)) != NULL) | |
312 | *p++ = to; | |
313 | ||
314 | return s; | |
315 | } | |
316 | ||
08aa9cce NK |
317 | /** |
318 | * ltrim - Removes leading whitespace from @s. | |
319 | * @s: The string to be stripped. | |
320 | * | |
321 | * Return pointer to the first non-whitespace character in @s. | |
322 | */ | |
323 | char *ltrim(char *s) | |
324 | { | |
325 | int len = strlen(s); | |
326 | ||
327 | while (len && isspace(*s)) { | |
328 | len--; | |
329 | s++; | |
330 | } | |
331 | ||
332 | return s; | |
333 | } | |
334 | ||
cb1a28a0 ACM |
335 | /** |
336 | * rtrim - Removes trailing whitespace from @s. | |
337 | * @s: The string to be stripped. | |
338 | * | |
339 | * Note that the first trailing whitespace is replaced with a %NUL-terminator | |
340 | * in the given string @s. Returns @s. | |
341 | */ | |
342 | char *rtrim(char *s) | |
343 | { | |
344 | size_t size = strlen(s); | |
345 | char *end; | |
346 | ||
347 | if (!size) | |
348 | return s; | |
349 | ||
350 | end = s + size - 1; | |
351 | while (end >= s && isspace(*end)) | |
352 | end--; | |
353 | *(end + 1) = '\0'; | |
354 | ||
355 | return s; | |
356 | } | |
b232e073 | 357 | |
93ec4ce7 ACM |
358 | char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints) |
359 | { | |
360 | /* | |
361 | * FIXME: replace this with an expression using log10() when we | |
362 | * find a suitable implementation, maybe the one in the dvb drivers... | |
363 | * | |
364 | * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators | |
365 | */ | |
366 | size_t size = nints * 28 + 1; /* \0 */ | |
367 | size_t i, printed = 0; | |
368 | char *expr = malloc(size); | |
369 | ||
370 | if (expr) { | |
371 | const char *or_and = "||", *eq_neq = "=="; | |
372 | char *e = expr; | |
373 | ||
374 | if (!in) { | |
375 | or_and = "&&"; | |
376 | eq_neq = "!="; | |
377 | } | |
378 | ||
379 | for (i = 0; i < nints; ++i) { | |
380 | if (printed == size) | |
381 | goto out_err_overflow; | |
382 | ||
383 | if (i > 0) | |
384 | printed += snprintf(e + printed, size - printed, " %s ", or_and); | |
385 | printed += scnprintf(e + printed, size - printed, | |
386 | "%s %s %d", var, eq_neq, ints[i]); | |
387 | } | |
388 | } | |
389 | ||
390 | return expr; | |
391 | ||
392 | out_err_overflow: | |
393 | free(expr); | |
394 | return NULL; | |
395 | } |