~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/tools/perf/util/string.c

Version: ~ [ linux-5.18 ] ~ [ linux-5.17.9 ] ~ [ linux-5.16.20 ] ~ [ linux-5.15.41 ] ~ [ linux-5.14.21 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.117 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.195 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.244 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.280 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.315 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.302 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.9 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp