deps/libretro-common/string/stdstring.c

   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 }