| 1 | /* Copyright (C) 2010-2020 The RetroArch team |
| 2 | * |
| 3 | * --------------------------------------------------------------------------------------- |
| 4 | * The following license statement only applies to this file (stdstring.c). |
| 5 | * --------------------------------------------------------------------------------------- |
| 6 | * |
| 7 | * Permission is hereby granted, free of charge, |
| 8 | * to any person obtaining a copy of this software and associated documentation files (the "Software"), |
| 9 | * to deal in the Software without restriction, including without limitation the rights to |
| 10 | * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, |
| 11 | * and to permit persons to whom the Software is furnished to do so, subject to the following conditions: |
| 12 | * |
| 13 | * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. |
| 14 | * |
| 15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, |
| 16 | * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| 17 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. |
| 18 | * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, |
| 19 | * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| 20 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| 21 | */ |
| 22 | |
| 23 | #include <stdint.h> |
| 24 | #include <ctype.h> |
| 25 | #include <string.h> |
| 26 | |
| 27 | #include <compat/strl.h> |
| 28 | #include <string/stdstring.h> |
| 29 | #include <encodings/utf.h> |
| 30 | |
| 31 | const uint8_t lr_char_props[256] = { |
| 32 | /*x0 x1 x2 x3 x4 x5 x6 x7 x8 x9 xA xB xC xD xE xF */ |
| 33 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x80,0x00,0x00,0x80,0x00,0x00, /* 0x */ |
| 34 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 1x */ |
| 35 | 0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 2x !"#$%&'()*+,-./ */ |
| 36 | 0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x41,0x00,0x00,0x00,0x00,0x00,0x00, /* 3x 0123456789:;<=>? */ |
| 37 | 0x00,0x23,0x23,0x23,0x23,0x23,0x23,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22, /* 4x @ABCDEFGHIJKLMNO */ |
| 38 | 0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x22,0x00,0x00,0x00,0x00,0x08, /* 5x PQRSTUVWXYZ[\]^_ */ |
| 39 | 0x00,0x25,0x25,0x25,0x25,0x25,0x25,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24, /* 6x `abcdefghijklmno */ |
| 40 | 0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x24,0x00,0x00,0x00,0x00,0x00, /* 7x pqrstuvwxyz{|}~ */ |
| 41 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 8x */ |
| 42 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 9x */ |
| 43 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ax */ |
| 44 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Bx */ |
| 45 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Cx */ |
| 46 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Dx */ |
| 47 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Ex */ |
| 48 | 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* Fx */ |
| 49 | }; |
| 50 | |
| 51 | char *string_init(const char *src) |
| 52 | { |
| 53 | return src ? strdup(src) : NULL; |
| 54 | } |
| 55 | |
| 56 | void string_set(char **string, const char *src) |
| 57 | { |
| 58 | free(*string); |
| 59 | *string = string_init(src); |
| 60 | } |
| 61 | |
| 62 | |
| 63 | char *string_to_upper(char *s) |
| 64 | { |
| 65 | char *cs = (char *)s; |
| 66 | for ( ; *cs != '\0'; cs++) |
| 67 | *cs = toupper((unsigned char)*cs); |
| 68 | return s; |
| 69 | } |
| 70 | |
| 71 | char *string_to_lower(char *s) |
| 72 | { |
| 73 | char *cs = (char *)s; |
| 74 | for ( ; *cs != '\0'; cs++) |
| 75 | *cs = tolower((unsigned char)*cs); |
| 76 | return s; |
| 77 | } |
| 78 | |
| 79 | char *string_ucwords(char *s) |
| 80 | { |
| 81 | char *cs = (char *)s; |
| 82 | for ( ; *cs != '\0'; cs++) |
| 83 | { |
| 84 | if (*cs == ' ') |
| 85 | *(cs+1) = toupper((unsigned char)*(cs+1)); |
| 86 | } |
| 87 | |
| 88 | s[0] = toupper((unsigned char)s[0]); |
| 89 | return s; |
| 90 | } |
| 91 | |
| 92 | char *string_replace_substring(const char *in, |
| 93 | const char *pattern, size_t pattern_len, |
| 94 | const char *replacement, size_t replacement_len) |
| 95 | { |
| 96 | size_t outlen; |
| 97 | size_t numhits = 0; |
| 98 | const char *inat = NULL; |
| 99 | const char *inprev = NULL; |
| 100 | char *out = NULL; |
| 101 | char *outat = NULL; |
| 102 | |
| 103 | /* if either pattern or replacement is NULL, |
| 104 | * duplicate in and let caller handle it. */ |
| 105 | if (!pattern || !replacement) |
| 106 | return strdup(in); |
| 107 | |
| 108 | inat = in; |
| 109 | |
| 110 | while ((inat = strstr(inat, pattern))) |
| 111 | { |
| 112 | inat += pattern_len; |
| 113 | numhits++; |
| 114 | } |
| 115 | |
| 116 | outlen = strlen(in) - pattern_len*numhits + replacement_len*numhits; |
| 117 | |
| 118 | if (!(out = (char *)malloc(outlen+1))) |
| 119 | return NULL; |
| 120 | |
| 121 | outat = out; |
| 122 | inat = in; |
| 123 | inprev = in; |
| 124 | |
| 125 | while ((inat = strstr(inat, pattern))) |
| 126 | { |
| 127 | memcpy(outat, inprev, inat-inprev); |
| 128 | outat += inat-inprev; |
| 129 | memcpy(outat, replacement, replacement_len); |
| 130 | outat += replacement_len; |
| 131 | inat += pattern_len; |
| 132 | inprev = inat; |
| 133 | } |
| 134 | strcpy(outat, inprev); |
| 135 | |
| 136 | return out; |
| 137 | } |
| 138 | |
| 139 | /** |
| 140 | * string_trim_whitespace_left: |
| 141 | * |
| 142 | * Remove leading whitespaces |
| 143 | **/ |
| 144 | char *string_trim_whitespace_left(char *const s) |
| 145 | { |
| 146 | if (s && *s) |
| 147 | { |
| 148 | size_t len = strlen(s); |
| 149 | char *current = s; |
| 150 | |
| 151 | while (*current && ISSPACE((unsigned char)*current)) |
| 152 | { |
| 153 | ++current; |
| 154 | --len; |
| 155 | } |
| 156 | |
| 157 | if (s != current) |
| 158 | memmove(s, current, len + 1); |
| 159 | } |
| 160 | |
| 161 | return s; |
| 162 | } |
| 163 | |
| 164 | /** |
| 165 | * string_trim_whitespace_right: |
| 166 | * |
| 167 | * Remove trailing whitespaces |
| 168 | **/ |
| 169 | char *string_trim_whitespace_right(char *const s) |
| 170 | { |
| 171 | if (s && *s) |
| 172 | { |
| 173 | size_t len = strlen(s); |
| 174 | char *current = s + len - 1; |
| 175 | |
| 176 | while (current != s && ISSPACE((unsigned char)*current)) |
| 177 | { |
| 178 | --current; |
| 179 | --len; |
| 180 | } |
| 181 | |
| 182 | current[ISSPACE((unsigned char)*current) ? 0 : 1] = '\0'; |
| 183 | } |
| 184 | |
| 185 | return s; |
| 186 | } |
| 187 | |
| 188 | /** |
| 189 | * string_trim_whitespace: |
| 190 | * |
| 191 | * Remove leading and trailing whitespaces |
| 192 | **/ |
| 193 | char *string_trim_whitespace(char *const s) |
| 194 | { |
| 195 | string_trim_whitespace_right(s); /* order matters */ |
| 196 | string_trim_whitespace_left(s); |
| 197 | |
| 198 | return s; |
| 199 | } |
| 200 | |
| 201 | /** |
| 202 | * word_wrap: |
| 203 | * @dst : pointer to destination buffer. |
| 204 | * @dst_size : size of destination buffer. |
| 205 | * @src : pointer to input string. |
| 206 | * @line_width : max number of characters per line. |
| 207 | * @wideglyph_width : not used, but is necessary to keep |
| 208 | * compatibility with word_wrap_wideglyph(). |
| 209 | * @max_lines : max lines of destination string. |
| 210 | * 0 means no limit. |
| 211 | * |
| 212 | * Wraps string specified by 'src' to destination buffer |
| 213 | * specified by 'dst' and 'dst_size'. |
| 214 | * This function assumes that all glyphs in the string |
| 215 | * have an on-screen pixel width similar to that of |
| 216 | * regular Latin characters - i.e. it will not wrap |
| 217 | * correctly any text containing so-called 'wide' Unicode |
| 218 | * characters (e.g. CJK languages, emojis, etc.). |
| 219 | **/ |
| 220 | void word_wrap( |
| 221 | char *dst, size_t dst_size, |
| 222 | const char *src, size_t src_len, |
| 223 | int line_width, int wideglyph_width, unsigned max_lines) |
| 224 | { |
| 225 | char *lastspace = NULL; |
| 226 | unsigned counter = 0; |
| 227 | unsigned lines = 1; |
| 228 | const char *src_end = src + src_len; |
| 229 | |
| 230 | /* Prevent buffer overflow */ |
| 231 | if (dst_size < src_len + 1) |
| 232 | return; |
| 233 | |
| 234 | /* Early return if src string length is less |
| 235 | * than line width */ |
| 236 | if (src_len < (size_t)line_width) |
| 237 | { |
| 238 | strlcpy(dst, src, dst_size); |
| 239 | return; |
| 240 | } |
| 241 | |
| 242 | while (*src != '\0') |
| 243 | { |
| 244 | unsigned char_len = (unsigned)(utf8skip(src, 1) - src); |
| 245 | counter++; |
| 246 | |
| 247 | if (*src == ' ') |
| 248 | lastspace = dst; /* Remember the location of the whitespace */ |
| 249 | else if (*src == '\n') |
| 250 | { |
| 251 | /* If newlines embedded in the input, |
| 252 | * reset the index */ |
| 253 | lines++; |
| 254 | counter = 0; |
| 255 | |
| 256 | /* Early return if remaining src string |
| 257 | * length is less than line width */ |
| 258 | if (src_end - src <= line_width) |
| 259 | { |
| 260 | strlcpy(dst, src, dst_size); |
| 261 | return; |
| 262 | } |
| 263 | } |
| 264 | |
| 265 | while (char_len--) |
| 266 | *dst++ = *src++; |
| 267 | |
| 268 | if (counter >= (unsigned)line_width) |
| 269 | { |
| 270 | counter = 0; |
| 271 | |
| 272 | if (lastspace && (max_lines == 0 || lines < max_lines)) |
| 273 | { |
| 274 | /* Replace nearest (previous) whitespace |
| 275 | * with newline character */ |
| 276 | *lastspace = '\n'; |
| 277 | lines++; |
| 278 | |
| 279 | src -= dst - lastspace - 1; |
| 280 | dst = lastspace + 1; |
| 281 | lastspace = NULL; |
| 282 | |
| 283 | /* Early return if remaining src string |
| 284 | * length is less than line width */ |
| 285 | if (src_end - src < line_width) |
| 286 | { |
| 287 | strlcpy(dst, src, dst_size); |
| 288 | return; |
| 289 | } |
| 290 | } |
| 291 | } |
| 292 | } |
| 293 | |
| 294 | *dst = '\0'; |
| 295 | } |
| 296 | |
| 297 | /** |
| 298 | * word_wrap_wideglyph: |
| 299 | * @dst : pointer to destination buffer. |
| 300 | * @dst_size : size of destination buffer. |
| 301 | * @src : pointer to input string. |
| 302 | * @line_width : max number of characters per line. |
| 303 | * @wideglyph_width : effective width of 'wide' Unicode glyphs. |
| 304 | * the value here is normalised relative to the |
| 305 | * typical on-screen pixel width of a regular |
| 306 | * Latin character: |
| 307 | * - a regular Latin character is defined to |
| 308 | * have an effective width of 100 |
| 309 | * - wideglyph_width = 100 * (wide_character_pixel_width / latin_character_pixel_width) |
| 310 | * - e.g. if 'wide' Unicode characters in 'src' |
| 311 | * have an on-screen pixel width twice that of |
| 312 | * regular Latin characters, wideglyph_width |
| 313 | * would be 200 |
| 314 | * @max_lines : max lines of destination string. |
| 315 | * 0 means no limit. |
| 316 | * |
| 317 | * Wraps string specified by @src to destination buffer |
| 318 | * specified by @dst and @dst_size. |
| 319 | * This function assumes that all glyphs in the string |
| 320 | * are: |
| 321 | * - EITHER 'non-wide' Unicode glyphs, with an on-screen |
| 322 | * pixel width similar to that of regular Latin characters |
| 323 | * - OR 'wide' Unicode glyphs (e.g. CJK languages, emojis, etc.) |
| 324 | * with an on-screen pixel width defined by @wideglyph_width |
| 325 | * Note that wrapping may occur in inappropriate locations |
| 326 | * if @src string contains 'wide' Unicode characters whose |
| 327 | * on-screen pixel width deviates greatly from the set |
| 328 | * @wideglyph_width value. |
| 329 | **/ |
| 330 | void word_wrap_wideglyph(char *dst, size_t dst_size, |
| 331 | const char *src, size_t src_len, int line_width, |
| 332 | int wideglyph_width, unsigned max_lines) |
| 333 | { |
| 334 | char *lastspace = NULL; |
| 335 | char *lastwideglyph = NULL; |
| 336 | const char *src_end = src + src_len; |
| 337 | unsigned lines = 1; |
| 338 | /* 'line_width' means max numbers of characters per line, |
| 339 | * but this metric is only meaningful when dealing with |
| 340 | * 'regular' glyphs that have an on-screen pixel width |
| 341 | * similar to that of regular Latin characters. |
| 342 | * When handing so-called 'wide' Unicode glyphs, it is |
| 343 | * necessary to consider the actual on-screen pixel width |
| 344 | * of each character. |
| 345 | * In order to do this, we create a distinction between |
| 346 | * regular Latin 'non-wide' glyphs and 'wide' glyphs, and |
| 347 | * normalise all values relative to the on-screen pixel |
| 348 | * width of regular Latin characters: |
| 349 | * - Regular 'non-wide' glyphs have a normalised width of 100 |
| 350 | * - 'line_width' is therefore normalised to 100 * (width_in_characters) |
| 351 | * - 'wide' glyphs have a normalised width of |
| 352 | * 100 * (wide_character_pixel_width / latin_character_pixel_width) |
| 353 | * - When a character is detected, the position in the current |
| 354 | * line is incremented by the regular normalised width of 100 |
| 355 | * - If that character is then determined to be a 'wide' |
| 356 | * glyph, the position in the current line is further incremented |
| 357 | * by the difference between the normalised 'wide' and 'non-wide' |
| 358 | * width values */ |
| 359 | unsigned counter_normalized = 0; |
| 360 | int line_width_normalized = line_width * 100; |
| 361 | int additional_counter_normalized = wideglyph_width - 100; |
| 362 | |
| 363 | /* Early return if src string length is less |
| 364 | * than line width */ |
| 365 | if (src_end - src < line_width) |
| 366 | { |
| 367 | strlcpy(dst, src, dst_size); |
| 368 | return; |
| 369 | } |
| 370 | |
| 371 | while (*src != '\0') |
| 372 | { |
| 373 | unsigned char_len = (unsigned)(utf8skip(src, 1) - src); |
| 374 | counter_normalized += 100; |
| 375 | |
| 376 | /* Prevent buffer overflow */ |
| 377 | if (char_len >= dst_size) |
| 378 | break; |
| 379 | |
| 380 | if (*src == ' ') |
| 381 | lastspace = dst; /* Remember the location of the whitespace */ |
| 382 | else if (*src == '\n') |
| 383 | { |
| 384 | /* If newlines embedded in the input, |
| 385 | * reset the index */ |
| 386 | lines++; |
| 387 | counter_normalized = 0; |
| 388 | |
| 389 | /* Early return if remaining src string |
| 390 | * length is less than line width */ |
| 391 | if (src_end - src <= line_width) |
| 392 | { |
| 393 | strlcpy(dst, src, dst_size); |
| 394 | return; |
| 395 | } |
| 396 | } |
| 397 | else if (char_len >= 3) |
| 398 | { |
| 399 | /* Remember the location of the first byte |
| 400 | * whose length as UTF-8 >= 3*/ |
| 401 | lastwideglyph = dst; |
| 402 | counter_normalized += additional_counter_normalized; |
| 403 | } |
| 404 | |
| 405 | dst_size -= char_len; |
| 406 | while (char_len--) |
| 407 | *dst++ = *src++; |
| 408 | |
| 409 | if (counter_normalized >= (unsigned)line_width_normalized) |
| 410 | { |
| 411 | counter_normalized = 0; |
| 412 | |
| 413 | if (max_lines != 0 && lines >= max_lines) |
| 414 | continue; |
| 415 | else if (lastwideglyph && (!lastspace || lastwideglyph > lastspace)) |
| 416 | { |
| 417 | /* Insert newline character */ |
| 418 | *lastwideglyph = '\n'; |
| 419 | lines++; |
| 420 | src -= dst - lastwideglyph; |
| 421 | dst = lastwideglyph + 1; |
| 422 | lastwideglyph = NULL; |
| 423 | |
| 424 | /* Early return if remaining src string |
| 425 | * length is less than line width */ |
| 426 | if (src_end - src <= line_width) |
| 427 | { |
| 428 | strlcpy(dst, src, dst_size); |
| 429 | return; |
| 430 | } |
| 431 | } |
| 432 | else if (lastspace) |
| 433 | { |
| 434 | /* Replace nearest (previous) whitespace |
| 435 | * with newline character */ |
| 436 | *lastspace = '\n'; |
| 437 | lines++; |
| 438 | src -= dst - lastspace - 1; |
| 439 | dst = lastspace + 1; |
| 440 | lastspace = NULL; |
| 441 | |
| 442 | /* Early return if remaining src string |
| 443 | * length is less than line width */ |
| 444 | if (src_end - src < line_width) |
| 445 | { |
| 446 | strlcpy(dst, src, dst_size); |
| 447 | return; |
| 448 | } |
| 449 | } |
| 450 | } |
| 451 | } |
| 452 | |
| 453 | *dst = '\0'; |
| 454 | } |
| 455 | |
| 456 | /** |
| 457 | * string_tokenize: |
| 458 | * |
| 459 | * Splits string into tokens seperated by @delim |
| 460 | * > Returned token string must be free()'d |
| 461 | * > Returns NULL if token is not found |
| 462 | * > After each call, @str is set to the position after the |
| 463 | * last found token |
| 464 | * > Tokens *include* empty strings |
| 465 | * Usage example: |
| 466 | * char *str = "1,2,3,4,5,6,7,,,10,"; |
| 467 | * char **str_ptr = &str; |
| 468 | * char *token = NULL; |
| 469 | * while ((token = string_tokenize(str_ptr, ","))) |
| 470 | * { |
| 471 | * printf("%s\n", token); |
| 472 | * free(token); |
| 473 | * token = NULL; |
| 474 | * } |
| 475 | **/ |
| 476 | char* string_tokenize(char **str, const char *delim) |
| 477 | { |
| 478 | /* Taken from https://codereview.stackexchange.com/questions/216956/strtok-function-thread-safe-supports-empty-tokens-doesnt-change-string# */ |
| 479 | char *str_ptr = NULL; |
| 480 | char *delim_ptr = NULL; |
| 481 | char *token = NULL; |
| 482 | size_t token_len = 0; |
| 483 | |
| 484 | /* Sanity checks */ |
| 485 | if (!str || string_is_empty(delim)) |
| 486 | return NULL; |
| 487 | |
| 488 | |
| 489 | /* Note: we don't check string_is_empty() here, |
| 490 | * empty strings are valid */ |
| 491 | if (!(str_ptr = *str)) |
| 492 | return NULL; |
| 493 | |
| 494 | /* Search for delimiter */ |
| 495 | if ((delim_ptr = strstr(str_ptr, delim))) |
| 496 | token_len = delim_ptr - str_ptr; |
| 497 | else |
| 498 | token_len = strlen(str_ptr); |
| 499 | |
| 500 | /* Allocate token string */ |
| 501 | if (!(token = (char *)malloc((token_len + 1) * sizeof(char)))) |
| 502 | return NULL; |
| 503 | |
| 504 | /* Copy token */ |
| 505 | strlcpy(token, str_ptr, (token_len + 1) * sizeof(char)); |
| 506 | token[token_len] = '\0'; |
| 507 | |
| 508 | /* Update input string pointer */ |
| 509 | *str = delim_ptr ? delim_ptr + strlen(delim) : NULL; |
| 510 | |
| 511 | return token; |
| 512 | } |
| 513 | |
| 514 | /** |
| 515 | * string_remove_all_chars: |
| 516 | * @str : input string (must be non-NULL, otherwise UB) |
| 517 | * |
| 518 | * Leaf function. |
| 519 | * |
| 520 | * Removes every instance of character @c from @str |
| 521 | **/ |
| 522 | void string_remove_all_chars(char *str, char c) |
| 523 | { |
| 524 | char *read_ptr = str; |
| 525 | char *write_ptr = str; |
| 526 | |
| 527 | while (*read_ptr != '\0') |
| 528 | { |
| 529 | *write_ptr = *read_ptr++; |
| 530 | if (*write_ptr != c) |
| 531 | write_ptr++; |
| 532 | } |
| 533 | |
| 534 | *write_ptr = '\0'; |
| 535 | } |
| 536 | |
| 537 | /** |
| 538 | * string_replace_all_chars: |
| 539 | * @str : input string (must be non-NULL, otherwise UB) |
| 540 | * @find : character to find |
| 541 | * @replace : character to replace @find with |
| 542 | * |
| 543 | * Replaces every instance of character @find in @str |
| 544 | * with character @replace |
| 545 | **/ |
| 546 | void string_replace_all_chars(char *str, char find, char replace) |
| 547 | { |
| 548 | char *str_ptr = str; |
| 549 | while ((str_ptr = strchr(str_ptr, find))) |
| 550 | *str_ptr++ = replace; |
| 551 | } |
| 552 | |
| 553 | /** |
| 554 | * string_to_unsigned: |
| 555 | * @str : input string |
| 556 | * |
| 557 | * Converts string to unsigned integer. |
| 558 | * |
| 559 | * @return 0 if string is invalid, otherwise > 0 |
| 560 | **/ |
| 561 | unsigned string_to_unsigned(const char *str) |
| 562 | { |
| 563 | const char *ptr = NULL; |
| 564 | |
| 565 | if (string_is_empty(str)) |
| 566 | return 0; |
| 567 | |
| 568 | for (ptr = str; *ptr != '\0'; ptr++) |
| 569 | { |
| 570 | if (!ISDIGIT((unsigned char)*ptr)) |
| 571 | return 0; |
| 572 | } |
| 573 | |
| 574 | return (unsigned)strtoul(str, NULL, 10); |
| 575 | } |
| 576 | |
| 577 | /** |
| 578 | * string_hex_to_unsigned: |
| 579 | * @str : input string (must be non-NULL, otherwise UB) |
| 580 | * |
| 581 | * Converts hexadecimal string to unsigned integer. |
| 582 | * Handles optional leading '0x'. |
| 583 | * |
| 584 | * @return 0 if string is invalid, otherwise > 0 |
| 585 | **/ |
| 586 | unsigned string_hex_to_unsigned(const char *str) |
| 587 | { |
| 588 | const char *hex_str = str; |
| 589 | const char *ptr = NULL; |
| 590 | |
| 591 | /* Remove leading '0x', if required */ |
| 592 | if (str[0] != '\0' && str[1] != '\0') |
| 593 | { |
| 594 | if ( (str[0] == '0') && |
| 595 | ((str[1] == 'x') || |
| 596 | (str[1] == 'X'))) |
| 597 | { |
| 598 | hex_str = str + 2; |
| 599 | if (string_is_empty(hex_str)) |
| 600 | return 0; |
| 601 | } |
| 602 | } |
| 603 | else |
| 604 | return 0; |
| 605 | |
| 606 | /* Check for valid characters */ |
| 607 | for (ptr = hex_str; *ptr != '\0'; ptr++) |
| 608 | { |
| 609 | if (!isxdigit((unsigned char)*ptr)) |
| 610 | return 0; |
| 611 | } |
| 612 | |
| 613 | return (unsigned)strtoul(hex_str, NULL, 16); |
| 614 | } |
| 615 | |
| 616 | /** |
| 617 | * string_count_occurrences_single_character: |
| 618 | * |
| 619 | * Leaf function. |
| 620 | * |
| 621 | * Get the total number of occurrences of character @c in @str. |
| 622 | * |
| 623 | * @return Total number of occurrences of character @c |
| 624 | */ |
| 625 | int string_count_occurrences_single_character(const char *str, char c) |
| 626 | { |
| 627 | int count = 0; |
| 628 | |
| 629 | for (; *str; str++) |
| 630 | if (*str == c) |
| 631 | count++; |
| 632 | |
| 633 | return count; |
| 634 | } |
| 635 | |
| 636 | /** |
| 637 | * string_replace_whitespace_with_single_character: |
| 638 | * |
| 639 | * Leaf function. |
| 640 | * |
| 641 | * Replaces all spaces with given character @c. |
| 642 | **/ |
| 643 | void string_replace_whitespace_with_single_character(char *str, char c) |
| 644 | { |
| 645 | for (; *str; str++) |
| 646 | if (ISSPACE(*str)) |
| 647 | *str = c; |
| 648 | } |
| 649 | |
| 650 | /** |
| 651 | * string_replace_multi_space_with_single_space: |
| 652 | * |
| 653 | * Leaf function. |
| 654 | * |
| 655 | * Replaces multiple spaces with a single space in a string. |
| 656 | **/ |
| 657 | void string_replace_multi_space_with_single_space(char *str) |
| 658 | { |
| 659 | char *str_trimmed = str; |
| 660 | bool prev_is_space = false; |
| 661 | bool curr_is_space = false; |
| 662 | |
| 663 | for (; *str; str++) |
| 664 | { |
| 665 | curr_is_space = ISSPACE(*str); |
| 666 | if (prev_is_space && curr_is_space) |
| 667 | continue; |
| 668 | *str_trimmed++ = *str; |
| 669 | prev_is_space = curr_is_space; |
| 670 | } |
| 671 | *str_trimmed = '\0'; |
| 672 | } |
| 673 | |
| 674 | /** |
| 675 | * string_remove_all_whitespace: |
| 676 | * |
| 677 | * Leaf function. |
| 678 | * |
| 679 | * Remove all spaces from the given string. |
| 680 | **/ |
| 681 | void string_remove_all_whitespace(char *str_trimmed, const char *str) |
| 682 | { |
| 683 | for (; *str; str++) |
| 684 | if (!ISSPACE(*str)) |
| 685 | *str_trimmed++ = *str; |
| 686 | *str_trimmed = '\0'; |
| 687 | } |
| 688 | |
| 689 | /** |
| 690 | * Retrieve the last occurance of the given character in a string. |
| 691 | */ |
| 692 | int string_index_last_occurance(const char *str, char c) |
| 693 | { |
| 694 | const char *pos = strrchr(str, c); |
| 695 | if (pos) |
| 696 | return (int)(pos - str); |
| 697 | return -1; |
| 698 | } |
| 699 | |
| 700 | /** |
| 701 | * string_find_index_substring_string: |
| 702 | * @str : input string (must be non-NULL, otherwise UB) |
| 703 | * @substr : substring to find in @str |
| 704 | * |
| 705 | * Find the position of substring @substr in string @str. |
| 706 | **/ |
| 707 | int string_find_index_substring_string(const char *str, const char *substr) |
| 708 | { |
| 709 | const char *pos = strstr(str, substr); |
| 710 | if (pos) |
| 711 | return (int)(pos - str); |
| 712 | return -1; |
| 713 | } |
| 714 | |
| 715 | /** |
| 716 | * string_copy_only_ascii: |
| 717 | * |
| 718 | * Leaf function. |
| 719 | * |
| 720 | * Strips non-ASCII characters from a string. |
| 721 | **/ |
| 722 | void string_copy_only_ascii(char *str_stripped, const char *str) |
| 723 | { |
| 724 | for (; *str; str++) |
| 725 | if (*str > 0x1F && *str < 0x7F) |
| 726 | *str_stripped++ = *str; |
| 727 | *str_stripped = '\0'; |
| 728 | } |