Changeset 08e103d4 in mainline for uspace/lib/c/generic/str.c


Ignore:
Timestamp:
2019-02-05T18:26:05Z (6 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Children:
1d2f85e
Parents:
d066259
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-05 16:16:55)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2019-02-05 18:26:05)
Message:

Use clearer naming for string length functions

This and the following commit change the names of functions, as well as
their documentation, to use unambiguous terms "bytes" and "code points"
instead of ambiguous terms "size", "length", and "characters".

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/str.c

    rd066259 r08e103d4  
    332332 *
    333333 */
    334 size_t str_size(const char *str)
     334size_t str_bytes(const char *str)
    335335{
    336336        size_t size = 0;
    … …  
    352352 *
    353353 */
    354 size_t wstr_size(const wchar_t *str)
    355 {
    356         return (wstr_length(str) * sizeof(wchar_t));
     354size_t wstr_bytes(const wchar_t *str)
     355{
     356        return (wstr_code_points(str) * sizeof(wchar_t));
    357357}
    358358
    … …  
    370370 *
    371371 */
    372 size_t str_lsize(const char *str, size_t max_len)
     372size_t str_lbytes(const char *str, size_t max_len)
    373373{
    374374        size_t len = 0;
    … …  
    396396 *
    397397 */
    398 size_t str_nsize(const char *str, size_t max_size)
     398size_t str_nbytes(const char *str, size_t max_size)
    399399{
    400400        size_t size = 0;
    … …  
    417417 *
    418418 */
    419 size_t wstr_nsize(const wchar_t *str, size_t max_size)
    420 {
    421         return (wstr_nlength(str, max_size) * sizeof(wchar_t));
     419size_t wstr_nbytes(const wchar_t *str, size_t max_size)
     420{
     421        return (wstr_ncode_points(str, max_size) * sizeof(wchar_t));
    422422}
    423423
    … …  
    435435 *
    436436 */
    437 size_t wstr_lsize(const wchar_t *str, size_t max_len)
    438 {
    439         return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
     437size_t wstr_lbytes(const wchar_t *str, size_t max_len)
     438{
     439        return (wstr_ncode_points(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
    440440}
    441441
    … …  
    447447 *
    448448 */
    449 size_t str_length(const char *str)
     449size_t str_code_points(const char *str)
    450450{
    451451        size_t len = 0;
    … …  
    465465 *
    466466 */
    467 size_t wstr_length(const wchar_t *wstr)
     467size_t wstr_code_points(const wchar_t *wstr)
    468468{
    469469        size_t len = 0;
    … …  
    483483 *
    484484 */
    485 size_t str_nlength(const char *str, size_t size)
     485size_t str_ncode_points(const char *str, size_t size)
    486486{
    487487        size_t len = 0;
    … …  
    502502 *
    503503 */
    504 size_t wstr_nlength(const wchar_t *str, size_t size)
     504size_t wstr_ncode_points(const wchar_t *str, size_t size)
    505505{
    506506        size_t len = 0;
    … …  
    616616 * Do a char-by-char comparison of two NULL-terminated strings.
    617617 * The strings are considered equal iff
    618  * min(str_length(s1), max_len) == min(str_length(s2), max_len)
     618 * min(str_code_points(s1), max_len) == min(str_code_points(s2), max_len)
    619619 * and both strings consist of the same sequence of characters,
    620620 * up to max_len characters.
    … …  
    716716 * Do a char-by-char comparison of two NULL-terminated strings.
    717717 * The strings are considered equal iff
    718  * min(str_length(s1), max_len) == min(str_length(s2), max_len)
     718 * min(str_code_points(s1), max_len) == min(str_code_points(s2), max_len)
    719719 * and both strings consist of the same sequence of characters,
    720720 * up to max_len characters.
    … …  
    879879void str_append(char *dest, size_t size, const char *src)
    880880{
    881         size_t dstr_size;
    882 
    883         dstr_size = str_size(dest);
    884         if (dstr_size >= size)
     881        size_t dstr_bytes;
     882
     883        dstr_bytes = str_bytes(dest);
     884        if (dstr_bytes >= size)
    885885                return;
    886886
    887         str_cpy(dest + dstr_size, size - dstr_size, src);
     887        str_cpy(dest + dstr_bytes, size - dstr_bytes, src);
    888888}
    889889
    … …  
    11781178wchar_t *str_to_awstr(const char *str)
    11791179{
    1180         size_t len = str_length(str);
     1180        size_t len = str_code_points(str);
    11811181
    11821182        wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
    … …  
    12211221        size_t off = 0;
    12221222
    1223         if (str_lcmp(hs, n, str_length(n)) == 0)
     1223        if (str_lcmp(hs, n, str_code_points(n)) == 0)
    12241224                return (char *)hs;
    12251225
    12261226        while (str_decode(hs, &off, STR_NO_LIMIT) != 0) {
    1227                 if (str_lcmp(hs + off, n, str_length(n)) == 0)
     1227                if (str_lcmp(hs + off, n, str_code_points(n)) == 0)
    12281228                        return (char *)(hs + off);
    12291229        }
    … …  
    12701270        size_t off = 0;
    12711271        size_t pos = 0;
    1272         size_t str_sz = str_size(str);
     1272        size_t str_sz = str_bytes(str);
    12731273
    12741274        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
    … …  
    13251325bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
    13261326{
    1327         size_t len = wstr_length(str);
     1327        size_t len = wstr_code_points(str);
    13281328
    13291329        if ((pos > len) || (pos + 1 > max_pos))
    … …  
    13531353bool wstr_remove(wchar_t *str, size_t pos)
    13541354{
    1355         size_t len = wstr_length(str);
     1355        size_t len = wstr_code_points(str);
    13561356
    13571357        if (pos >= len)
    … …  
    13831383char *str_dup(const char *src)
    13841384{
    1385         size_t size = str_size(src) + 1;
     1385        size_t size = str_bytes(src) + 1;
    13861386        char *dest = malloc(size);
    13871387        if (!dest)
    … …  
    14141414char *str_ndup(const char *src, size_t n)
    14151415{
    1416         size_t size = str_size(src);
     1416        size_t size = str_bytes(src);
    14171417        if (size > n)
    14181418                size = n;
    … …  
    14451445                return NULL;
    14461446
    1447         size_t len = str_size(s);
     1447        size_t len = str_bytes(s);
    14481448        size_t cur;
    14491449        size_t tmp;
Note: See TracChangeset for help on using the changeset viewer.