Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
a067558e ACM |
2 | #include "string2.h" |
3 | #include <linux/kernel.h> | |
4 | #include <linux/string.h> | |
5 | #include <stdlib.h> | |
ea5cc87c | 6 | |
3052ba56 | 7 | #include <linux/ctype.h> |
3d689ed6 | 8 | |
6a9fa4e3 ACM |
9 | const char *graph_dotted_line = |
10 | "---------------------------------------------------------------------" | |
11 | "---------------------------------------------------------------------" | |
12 | "---------------------------------------------------------------------"; | |
13 | const char *dots = | |
14 | "....................................................................." | |
15 | "....................................................................." | |
16 | "....................................................................."; | |
17 | ||
d2fb8b41 HM |
18 | /* |
19 | * perf_atoll() | |
20 | * Parse (\d+)(b|B|kb|KB|mb|MB|gb|GB|tb|TB) (e.g. "256MB") | |
21 | * and return its numeric value | |
22 | */ | |
23 | s64 perf_atoll(const char *str) | |
24 | { | |
8ba7f6c2 AV |
25 | s64 length; |
26 | char *p; | |
27 | char c; | |
d2fb8b41 HM |
28 | |
29 | if (!isdigit(str[0])) | |
30 | goto out_err; | |
31 | ||
8ba7f6c2 AV |
32 | length = strtoll(str, &p, 10); |
33 | switch (c = *p++) { | |
34 | case 'b': case 'B': | |
35 | if (*p) | |
d2fb8b41 | 36 | goto out_err; |
94bdd5ed | 37 | |
f7a858bf | 38 | fallthrough; |
8ba7f6c2 AV |
39 | case '\0': |
40 | return length; | |
41 | default: | |
42 | goto out_err; | |
43 | /* two-letter suffices */ | |
44 | case 'k': case 'K': | |
45 | length <<= 10; | |
d2fb8b41 | 46 | break; |
8ba7f6c2 AV |
47 | case 'm': case 'M': |
48 | length <<= 20; | |
d2fb8b41 | 49 | break; |
8ba7f6c2 AV |
50 | case 'g': case 'G': |
51 | length <<= 30; | |
d2fb8b41 | 52 | break; |
8ba7f6c2 AV |
53 | case 't': case 'T': |
54 | length <<= 40; | |
d2fb8b41 | 55 | break; |
d2fb8b41 | 56 | } |
8ba7f6c2 AV |
57 | /* we want the cases to match */ |
58 | if (islower(c)) { | |
59 | if (strcmp(p, "b") != 0) | |
60 | goto out_err; | |
61 | } else { | |
62 | if (strcmp(p, "B") != 0) | |
63 | goto out_err; | |
64 | } | |
65 | return length; | |
d2fb8b41 HM |
66 | |
67 | out_err: | |
8ba7f6c2 | 68 | return -1; |
d2fb8b41 | 69 | } |
e1c01d61 | 70 | |
6964cd2c MH |
71 | /* Character class matching */ |
72 | static bool __match_charclass(const char *pat, char c, const char **npat) | |
73 | { | |
74 | bool complement = false, ret = true; | |
75 | ||
76 | if (*pat == '!') { | |
77 | complement = true; | |
78 | pat++; | |
79 | } | |
80 | if (*pat++ == c) /* First character is special */ | |
81 | goto end; | |
82 | ||
83 | while (*pat && *pat != ']') { /* Matching */ | |
84 | if (*pat == '-' && *(pat + 1) != ']') { /* Range */ | |
85 | if (*(pat - 1) <= c && c <= *(pat + 1)) | |
86 | goto end; | |
87 | if (*(pat - 1) > *(pat + 1)) | |
88 | goto error; | |
89 | pat += 2; | |
90 | } else if (*pat++ == c) | |
91 | goto end; | |
92 | } | |
93 | if (!*pat) | |
94 | goto error; | |
95 | ret = false; | |
96 | ||
97 | end: | |
98 | while (*pat && *pat != ']') /* Searching closing */ | |
99 | pat++; | |
100 | if (!*pat) | |
101 | goto error; | |
102 | *npat = pat + 1; | |
103 | return complement ? !ret : ret; | |
104 | ||
105 | error: | |
106 | return false; | |
107 | } | |
108 | ||
2a9c8c36 | 109 | /* Glob/lazy pattern matching */ |
38d14f0c AK |
110 | static bool __match_glob(const char *str, const char *pat, bool ignore_space, |
111 | bool case_ins) | |
bbbb521b MH |
112 | { |
113 | while (*str && *pat && *pat != '*') { | |
2a9c8c36 MH |
114 | if (ignore_space) { |
115 | /* Ignore spaces for lazy matching */ | |
116 | if (isspace(*str)) { | |
117 | str++; | |
118 | continue; | |
119 | } | |
120 | if (isspace(*pat)) { | |
121 | pat++; | |
122 | continue; | |
123 | } | |
124 | } | |
6964cd2c | 125 | if (*pat == '?') { /* Matches any single character */ |
bbbb521b MH |
126 | str++; |
127 | pat++; | |
6964cd2c MH |
128 | continue; |
129 | } else if (*pat == '[') /* Character classes/Ranges */ | |
130 | if (__match_charclass(pat + 1, *str, &pat)) { | |
131 | str++; | |
132 | continue; | |
133 | } else | |
bbbb521b | 134 | return false; |
6964cd2c MH |
135 | else if (*pat == '\\') /* Escaped char match as normal char */ |
136 | pat++; | |
38d14f0c AK |
137 | if (case_ins) { |
138 | if (tolower(*str) != tolower(*pat)) | |
139 | return false; | |
140 | } else if (*str != *pat) | |
6964cd2c | 141 | return false; |
38d14f0c AK |
142 | str++; |
143 | pat++; | |
bbbb521b MH |
144 | } |
145 | /* Check wild card */ | |
146 | if (*pat == '*') { | |
147 | while (*pat == '*') | |
148 | pat++; | |
149 | if (!*pat) /* Tail wild card matches all */ | |
150 | return true; | |
151 | while (*str) | |
38d14f0c | 152 | if (__match_glob(str++, pat, ignore_space, case_ins)) |
bbbb521b MH |
153 | return true; |
154 | } | |
155 | return !*str && !*pat; | |
156 | } | |
157 | ||
2a9c8c36 MH |
158 | /** |
159 | * strglobmatch - glob expression pattern matching | |
160 | * @str: the target string to match | |
161 | * @pat: the pattern string to match | |
162 | * | |
163 | * This returns true if the @str matches @pat. @pat can includes wildcards | |
164 | * ('*','?') and character classes ([CHARS], complementation and ranges are | |
165 | * also supported). Also, this supports escape character ('\') to use special | |
166 | * characters as normal character. | |
167 | * | |
168 | * Note: if @pat syntax is broken, this always returns false. | |
169 | */ | |
170 | bool strglobmatch(const char *str, const char *pat) | |
171 | { | |
38d14f0c AK |
172 | return __match_glob(str, pat, false, false); |
173 | } | |
174 | ||
175 | bool strglobmatch_nocase(const char *str, const char *pat) | |
176 | { | |
177 | return __match_glob(str, pat, false, true); | |
2a9c8c36 MH |
178 | } |
179 | ||
180 | /** | |
181 | * strlazymatch - matching pattern strings lazily with glob pattern | |
182 | * @str: the target string to match | |
183 | * @pat: the pattern string to match | |
184 | * | |
185 | * This is similar to strglobmatch, except this ignores spaces in | |
186 | * the target string. | |
187 | */ | |
188 | bool strlazymatch(const char *str, const char *pat) | |
189 | { | |
38d14f0c | 190 | return __match_glob(str, pat, true, false); |
2a9c8c36 | 191 | } |
bad03ae4 MH |
192 | |
193 | /** | |
194 | * strtailcmp - Compare the tail of two strings | |
195 | * @s1: 1st string to be compared | |
196 | * @s2: 2nd string to be compared | |
197 | * | |
198 | * Return 0 if whole of either string is same as another's tail part. | |
199 | */ | |
200 | int strtailcmp(const char *s1, const char *s2) | |
201 | { | |
202 | int i1 = strlen(s1); | |
203 | int i2 = strlen(s2); | |
204 | while (--i1 >= 0 && --i2 >= 0) { | |
205 | if (s1[i1] != s2[i2]) | |
206 | return s1[i1] - s2[i2]; | |
207 | } | |
208 | return 0; | |
209 | } | |
210 | ||
93ec4ce7 ACM |
211 | char *asprintf_expr_inout_ints(const char *var, bool in, size_t nints, int *ints) |
212 | { | |
213 | /* | |
214 | * FIXME: replace this with an expression using log10() when we | |
215 | * find a suitable implementation, maybe the one in the dvb drivers... | |
216 | * | |
217 | * "%s == %d || " = log10(MAXINT) * 2 + 8 chars for the operators | |
218 | */ | |
219 | size_t size = nints * 28 + 1; /* \0 */ | |
220 | size_t i, printed = 0; | |
221 | char *expr = malloc(size); | |
222 | ||
223 | if (expr) { | |
224 | const char *or_and = "||", *eq_neq = "=="; | |
225 | char *e = expr; | |
226 | ||
227 | if (!in) { | |
228 | or_and = "&&"; | |
229 | eq_neq = "!="; | |
230 | } | |
231 | ||
232 | for (i = 0; i < nints; ++i) { | |
233 | if (printed == size) | |
234 | goto out_err_overflow; | |
235 | ||
236 | if (i > 0) | |
a067558e | 237 | printed += scnprintf(e + printed, size - printed, " %s ", or_and); |
93ec4ce7 ACM |
238 | printed += scnprintf(e + printed, size - printed, |
239 | "%s %s %d", var, eq_neq, ints[i]); | |
240 | } | |
241 | } | |
242 | ||
243 | return expr; | |
244 | ||
245 | out_err_overflow: | |
246 | free(expr); | |
247 | return NULL; | |
248 | } | |
1e9f9e8a MH |
249 | |
250 | /* Like strpbrk(), but not break if it is right after a backslash (escaped) */ | |
251 | char *strpbrk_esc(char *str, const char *stopset) | |
252 | { | |
253 | char *ptr; | |
254 | ||
255 | do { | |
256 | ptr = strpbrk(str, stopset); | |
257 | if (ptr == str || | |
258 | (ptr == str + 1 && *(ptr - 1) != '\\')) | |
259 | break; | |
260 | str = ptr + 1; | |
261 | } while (ptr && *(ptr - 1) == '\\' && *(ptr - 2) != '\\'); | |
262 | ||
263 | return ptr; | |
264 | } | |
265 | ||
266 | /* Like strdup, but do not copy a single backslash */ | |
267 | char *strdup_esc(const char *str) | |
268 | { | |
269 | char *s, *d, *p, *ret = strdup(str); | |
270 | ||
271 | if (!ret) | |
272 | return NULL; | |
273 | ||
274 | d = strchr(ret, '\\'); | |
275 | if (!d) | |
276 | return ret; | |
277 | ||
278 | s = d + 1; | |
279 | do { | |
280 | if (*s == '\0') { | |
281 | *d = '\0'; | |
282 | break; | |
283 | } | |
284 | p = strchr(s + 1, '\\'); | |
285 | if (p) { | |
286 | memmove(d, s, p - s); | |
287 | d += p - s; | |
288 | s = p + 1; | |
289 | } else | |
290 | memmove(d, s, strlen(s) + 1); | |
291 | } while (p); | |
292 | ||
293 | return ret; | |
294 | } | |
cef7af25 FH |
295 | |
296 | unsigned int hex(char c) | |
297 | { | |
298 | if (c >= '0' && c <= '9') | |
299 | return c - '0'; | |
300 | if (c >= 'a' && c <= 'f') | |
301 | return c - 'a' + 10; | |
302 | return c - 'A' + 10; | |
303 | } | |
8a55c1e2 JC |
304 | |
305 | /* | |
306 | * Replace all occurrences of character 'needle' in string 'haystack' with | |
307 | * string 'replace' | |
308 | * | |
309 | * The new string could be longer so a new string is returned which must be | |
310 | * freed. | |
311 | */ | |
312 | char *strreplace_chars(char needle, const char *haystack, const char *replace) | |
313 | { | |
314 | int replace_len = strlen(replace); | |
315 | char *new_s, *to; | |
316 | const char *loc = strchr(haystack, needle); | |
317 | const char *from = haystack; | |
318 | int num = 0; | |
319 | ||
320 | /* Count occurrences */ | |
321 | while (loc) { | |
322 | loc = strchr(loc + 1, needle); | |
323 | num++; | |
324 | } | |
325 | ||
326 | /* Allocate enough space for replacements and reset first location */ | |
327 | new_s = malloc(strlen(haystack) + (num * (replace_len - 1) + 1)); | |
328 | if (!new_s) | |
329 | return NULL; | |
330 | loc = strchr(haystack, needle); | |
331 | to = new_s; | |
332 | ||
333 | while (loc) { | |
334 | /* Copy original string up to found char and update positions */ | |
335 | memcpy(to, from, 1 + loc - from); | |
336 | to += loc - from; | |
337 | from = loc + 1; | |
338 | ||
339 | /* Copy replacement string and update positions */ | |
340 | memcpy(to, replace, replace_len); | |
341 | to += replace_len; | |
342 | ||
343 | /* needle next occurrence or end of string */ | |
344 | loc = strchr(from, needle); | |
345 | } | |
346 | ||
347 | /* Copy any remaining chars + null */ | |
348 | strcpy(to, from); | |
349 | ||
350 | return new_s; | |
351 | } |