Changeset 08e103d4 in mainline for uspace/lib/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".

Location:
uspace/lib/c
Files:
27 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/c/generic/arg_parse.c

    rd066259 r08e103d4  
    4040                return 0;
    4141
    42         if (str_lcmp(arg, along, str_length(along)) == 0)
    43                 return str_length(along);
     42        if (str_lcmp(arg, along, str_code_points(along)) == 0)
     43                return str_code_points(along);
    4444
    4545        return -1;

  • uspace/lib/c/generic/cap.c

    rd066259 r08e103d4  
    285285                for (i = 0; i < CU_LIMIT; i++) {
    286286                        if (str_lcasecmp(eptr, cu_str[i],
    287                             str_length(cu_str[i])) == 0) {
    288                                 p = eptr + str_size(cu_str[i]);
     287                            str_code_points(cu_str[i])) == 0) {
     288                                p = eptr + str_bytes(cu_str[i]);
    289289                                while (*p == ' ')
    290290                                        ++p;

  • uspace/lib/c/generic/clipboard.c

    rd066259 r08e103d4  
    100100errno_t clipboard_put_str(const char *str)
    101101{
    102         size_t size = str_size(str);
     102        size_t size = str_bytes(str);
    103103
    104104        if (size == 0) {

  • uspace/lib/c/generic/devman.c

    rd066259 r08e103d4  
    182182        ipc_call_t answer;
    183183        aid_t req = async_send_2(exch, DEVMAN_DRIVER_REGISTER, 0, 0, &answer);
    184         errno_t retval = async_data_write_start(exch, name, str_size(name));
     184        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    185185
    186186        devman_exchange_end(exch);
    … …  
    222222        aid_t req = async_send_3(exch, DEVMAN_ADD_FUNCTION, (sysarg_t) ftype,
    223223            devh, match_count, &answer);
    224         errno_t retval = async_data_write_start(exch, name, str_size(name));
     224        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    225225        if (retval != EOK) {
    226226                devman_exchange_end(exch);
    … …  
    234234                    match_id->score, &answer2);
    235235                retval = async_data_write_start(exch, match_id->id,
    236                     str_size(match_id->id));
     236                    str_bytes(match_id->id));
    237237                if (retval != EOK) {
    238238                        devman_exchange_end(exch);
    … …  
    273273            devman_handle, &answer);
    274274        errno_t retval = async_data_write_start(exch, cat_name,
    275             str_size(cat_name));
     275            str_bytes(cat_name));
    276276
    277277        devman_exchange_end(exch);
    … …  
    375375            &answer);
    376376        errno_t retval = async_data_write_start(exch, pathname,
    377             str_size(pathname));
     377            str_bytes(pathname));
    378378
    379379        devman_exchange_end(exch);
    … …  
    644644        aid_t req = async_send_0(exch, DEVMAN_DRIVER_GET_HANDLE, &answer);
    645645        errno_t retval = async_data_write_start(exch, drvname,
    646             str_size(drvname));
     646            str_bytes(drvname));
    647647
    648648        devman_exchange_end(exch);

  • uspace/lib/c/generic/dnsr.c

    rd066259 r08e103d4  
    7575            &answer);
    7676
    77         errno_t rc = async_data_write_start(exch, name, str_size(name));
     77        errno_t rc = async_data_write_start(exch, name, str_bytes(name));
    7878        if (rc != EOK) {
    7979                async_exchange_end(exch);

  • uspace/lib/c/generic/getopt.c

    rd066259 r08e103d4  
    366366                        has_equal++;
    367367                } else
    368                         current_argv_len = str_size(current_argv);
     368                        current_argv_len = str_bytes(current_argv);
    369369
    370370                for (i = 0; long_options[i].name; i++) {
    371371                        /* find matching long option */
    372372                        if (str_lcmp(current_argv, long_options[i].name,
    373                             str_nlength(current_argv, current_argv_len)))
     373                            str_ncode_points(current_argv, current_argv_len)))
    374374                                continue;
    375375
    376                         if (str_size(long_options[i].name) ==
     376                        if (str_bytes(long_options[i].name) ==
    377377                            (unsigned)current_argv_len) {
    378378                                /* exact match */

  • uspace/lib/c/generic/inetcfg.c

    rd066259 r08e103d4  
    149149        }
    150150
    151         rc = async_data_write_start(exch, name, str_size(name));
     151        rc = async_data_write_start(exch, name, str_bytes(name));
    152152
    153153        async_exchange_end(exch);
    … …  
    234234        ipc_call_t answer;
    235235        aid_t req = async_send_1(exch, INETCFG_ADDR_GET_ID, link_id, &answer);
    236         errno_t retval = async_data_write_start(exch, name, str_size(name));
     236        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    237237
    238238        async_exchange_end(exch);
    … …  
    347347        }
    348348
    349         rc = async_data_write_start(exch, name, str_size(name));
     349        rc = async_data_write_start(exch, name, str_bytes(name));
    350350
    351351        async_exchange_end(exch);
    … …  
    444444        ipc_call_t answer;
    445445        aid_t req = async_send_0(exch, INETCFG_SROUTE_GET_ID, &answer);
    446         errno_t retval = async_data_write_start(exch, name, str_size(name));
     446        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    447447
    448448        async_exchange_end(exch);

  • uspace/lib/c/generic/io/asprintf.c

    rd066259 r08e103d4  
    4343static int asprintf_str_write(const char *str, size_t count, void *unused)
    4444{
    45         return str_nlength(str, count);
     45        return str_ncode_points(str, count);
    4646}
    4747
    4848static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
    4949{
    50         return wstr_nlength(str, count);
     50        return wstr_ncode_points(str, count);
    5151}
    5252
    53 int vprintf_length(const char *fmt, va_list args)
     53int vprintf_code_points(const char *fmt, va_list args)
    5454{
    5555        printf_spec_t ps = {
    … …  
    6262}
    6363
    64 int printf_length(const char *fmt, ...)
     64int printf_code_points(const char *fmt, ...)
    6565{
    6666        va_list args;
    6767        va_start(args, fmt);
    68         int ret = vprintf_length(fmt, args);
     68        int ret = vprintf_code_points(fmt, args);
    6969        va_end(args);
    7070

  • uspace/lib/c/generic/io/io.c

    rd066259 r08e103d4  
    774774int fputs(const char *str, FILE *stream)
    775775{
    776         (void) fwrite(str, str_size(str), 1, stream);
     776        (void) fwrite(str, str_bytes(str), 1, stream);
    777777        if (ferror(stream))
    778778                return EOF;

  • uspace/lib/c/generic/io/kio.c

    rd066259 r08e103d4  
    137137        wr = 0;
    138138        (void) kio_write(str, size, &wr);
    139         return str_nlength(str, wr);
     139        return str_ncode_points(str, wr);
    140140}
    141141

  • uspace/lib/c/generic/io/log.c

    rd066259 r08e103d4  
    8989        aid_t reg_msg = async_send_2(exchange, LOGGER_WRITER_MESSAGE,
    9090            log, level, NULL);
    91         errno_t rc = async_data_write_start(exchange, message, str_size(message));
     91        errno_t rc = async_data_write_start(exchange, message, str_bytes(message));
    9292        errno_t reg_msg_rc;
    9393        async_wait_for(reg_msg, &reg_msg_rc);
    … …  
    144144        char *end_ptr;
    145145        int level_int = strtol(name, &end_ptr, 0);
    146         if ((end_ptr == name) || (str_length(end_ptr) != 0))
     146        if ((end_ptr == name) || (str_code_points(end_ptr) != 0))
    147147                return EINVAL;
    148148        if (level_int < 0)
    … …  
    199199        aid_t reg_msg = async_send_1(exchange, LOGGER_WRITER_CREATE_LOG,
    200200            parent, &answer);
    201         errno_t rc = async_data_write_start(exchange, name, str_size(name));
     201        errno_t rc = async_data_write_start(exchange, name, str_bytes(name));
    202202        errno_t reg_msg_rc;
    203203        async_wait_for(reg_msg, &reg_msg_rc);

  • uspace/lib/c/generic/io/logctl.c

    rd066259 r08e103d4  
    110110        aid_t reg_msg = async_send_1(exchange, LOGGER_CONTROL_SET_LOG_LEVEL,
    111111            new_level, NULL);
    112         rc = async_data_write_start(exchange, logname, str_size(logname));
     112        rc = async_data_write_start(exchange, logname, str_bytes(logname));
    113113        errno_t reg_msg_rc;
    114114        async_wait_for(reg_msg, &reg_msg_rc);

  • uspace/lib/c/generic/io/printf_core.c

    rd066259 r08e103d4  
    204204{
    205205        if (str == NULL)
    206                 return printf_putnchars(nullstr, str_size(nullstr), ps);
    207 
    208         return ps->str_write((void *) str, str_size(str), ps->data);
     206                return printf_putnchars(nullstr, str_bytes(nullstr), ps);
     207
     208        return ps->str_write((void *) str, str_bytes(str), ps->data);
    209209}
    210210
    … …  
    332332                return printf_putstr(nullstr, ps);
    333333
    334         size_t strw = str_length(str);
     334        size_t strw = str_code_points(str);
    335335
    336336        /* Precision unspecified - print everything. */
    … …  
    350350        /* Part of @a str fitting into the alloted space. */
    351351        int retval;
    352         size_t size = str_lsize(str, precision);
     352        size_t size = str_lbytes(str, precision);
    353353        if ((retval = printf_putnchars(str, size, ps)) < 0)
    354354                return -counter;
    … …  
    381381                return printf_putstr(nullstr, ps);
    382382
    383         size_t strw = wstr_length(str);
     383        size_t strw = wstr_code_points(str);
    384384
    385385        /* Precision not specified - print everything. */
    … …  
    399399        /* Part of @a wstr fitting into the alloted space. */
    400400        int retval;
    401         size_t size = wstr_lsize(str, precision);
     401        size_t size = wstr_lbytes(str, precision);
    402402        if ((retval = printf_wputnchars(str, size, ps)) < 0)
    403403                return -counter;

  • uspace/lib/c/generic/io/vprintf.c

    rd066259 r08e103d4  
    4545{
    4646        size_t wr = fwrite(str, 1, size, (FILE *) stream);
    47         return str_nlength(str, wr);
     47        return str_ncode_points(str, wr);
    4848}
    4949

  • uspace/lib/c/generic/loader.c

    rd066259 r08e103d4  
    5757{
    5858        return (errno_t) __SYSCALL2(SYS_PROGRAM_SPAWN_LOADER,
    59             (sysarg_t) name, str_size(name));
     59            (sysarg_t) name, str_bytes(name));
    6060}
    6161
    … …  
    125125                str_cpy(cwd, MAX_PATH_LEN + 1, "/");
    126126
    127         size_t len = str_length(cwd);
     127        size_t len = str_code_points(cwd);
    128128
    129129        async_exch_t *exch = async_exchange_begin(ldr->sess);
    … …  
    161161        aid_t req = async_send_0(exch, LOADER_SET_PROGRAM, &answer);
    162162
    163         errno_t rc = async_data_write_start(exch, name, str_size(name) + 1);
     163        errno_t rc = async_data_write_start(exch, name, str_bytes(name) + 1);
    164164        if (rc == EOK) {
    165165                async_exch_t *vfs_exch = vfs_exchange_begin();
    … …  
    226226        size_t buffer_size = 0;
    227227        while (*ap != NULL) {
    228                 buffer_size += str_size(*ap) + 1;
     228                buffer_size += str_bytes(*ap) + 1;
    229229                ap++;
    230230        }
    … …  
    240240        while (*ap != NULL) {
    241241                str_cpy(dp, buffer_size - (dp - arg_buf), *ap);
    242                 dp += str_size(*ap) + 1;
     242                dp += str_bytes(*ap) + 1;
    243243                ap++;
    244244        }
    … …  
    280280        aid_t req = async_send_0(exch, LOADER_ADD_INBOX, NULL);
    281281
    282         errno_t rc = async_data_write_start(exch, name, str_size(name) + 1);
     282        errno_t rc = async_data_write_start(exch, name, str_bytes(name) + 1);
    283283        if (rc == EOK) {
    284284                rc = vfs_pass_handle(vfs_exch, file, exch);

  • uspace/lib/c/generic/loc.c

    rd066259 r08e103d4  
    246246        ipc_call_t answer;
    247247        aid_t req = async_send_2(exch, LOC_SERVER_REGISTER, 0, 0, &answer);
    248         errno_t retval = async_data_write_start(exch, name, str_size(name));
     248        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    249249
    250250        if (retval != EOK) {
    … …  
    279279        ipc_call_t answer;
    280280        aid_t req = async_send_0(exch, LOC_SERVICE_REGISTER, &answer);
    281         errno_t retval = async_data_write_start(exch, fqsn, str_size(fqsn));
     281        errno_t retval = async_data_write_start(exch, fqsn, str_bytes(fqsn));
    282282
    283283        if (retval != EOK) {
    … …  
    340340        aid_t req = async_send_2(exch, LOC_SERVICE_GET_ID, flags, 0,
    341341            &answer);
    342         errno_t retval = async_data_write_start(exch, fqdn, str_size(fqdn));
     342        errno_t retval = async_data_write_start(exch, fqdn, str_bytes(fqdn));
    343343
    344344        loc_exchange_end(exch);
    … …  
    473473        aid_t req = async_send_2(exch, LOC_NAMESPACE_GET_ID, flags, 0,
    474474            &answer);
    475         errno_t retval = async_data_write_start(exch, name, str_size(name));
     475        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    476476
    477477        loc_exchange_end(exch);
    … …  
    522522        aid_t req = async_send_0(exch, LOC_CATEGORY_GET_ID,
    523523            &answer);
    524         errno_t retval = async_data_write_start(exch, name, str_size(name));
     524        errno_t retval = async_data_write_start(exch, name, str_bytes(name));
    525525
    526526        loc_exchange_end(exch);

  • uspace/lib/c/generic/rtld/module.c

    rd066259 r08e103d4  
    196196                m->local = true;
    197197
    198         if (str_size(name) > NAME_BUF_SIZE - 2) {
     198        if (str_bytes(name) > NAME_BUF_SIZE - 2) {
    199199                printf("soname too long. increase NAME_BUF_SIZE\n");
    200200                exit(1);

  • 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;

  • uspace/lib/c/generic/sysinfo.c

    rd066259 r08e103d4  
    5252{
    5353        return (errno_t) __SYSCALL3(SYS_SYSINFO_GET_KEYS_SIZE, (sysarg_t) path,
    54             (sysarg_t) str_size(path), (sysarg_t) size);
     54            (sysarg_t) str_bytes(path), (sysarg_t) size);
    5555}
    5656
    … …  
    9393        size_t sz;
    9494        ret = (errno_t) __SYSCALL5(SYS_SYSINFO_GET_KEYS, (sysarg_t) path,
    95             (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
     95            (sysarg_t) str_bytes(path), (sysarg_t) data, (sysarg_t) *size,
    9696            (sysarg_t) &sz);
    9797        if (ret == EOK) {
    … …  
    115115{
    116116        return (sysinfo_item_val_type_t) __SYSCALL2(SYS_SYSINFO_GET_VAL_TYPE,
    117             (sysarg_t) path, (sysarg_t) str_size(path));
     117            (sysarg_t) path, (sysarg_t) str_bytes(path));
    118118}
    119119
    … …  
    130130{
    131131        return (errno_t) __SYSCALL3(SYS_SYSINFO_GET_VALUE, (sysarg_t) path,
    132             (sysarg_t) str_size(path), (sysarg_t) value);
     132            (sysarg_t) str_bytes(path), (sysarg_t) value);
    133133}
    134134
    … …  
    145145{
    146146        return (errno_t) __SYSCALL3(SYS_SYSINFO_GET_DATA_SIZE, (sysarg_t) path,
    147             (sysarg_t) str_size(path), (sysarg_t) size);
     147            (sysarg_t) str_bytes(path), (sysarg_t) size);
    148148}
    149149
    … …  
    187187        size_t sz;
    188188        ret = (errno_t) __SYSCALL5(SYS_SYSINFO_GET_DATA, (sysarg_t) path,
    189             (sysarg_t) str_size(path), (sysarg_t) data, (sysarg_t) *size,
     189            (sysarg_t) str_bytes(path), (sysarg_t) data, (sysarg_t) *size,
    190190            (sysarg_t) &sz);
    191191        if (ret == EOK) {
    … …  
    223223        while (pos < total_size) {
    224224                /* Process each property with sanity checks */
    225                 size_t cur_size = str_nsize(data + pos, total_size - pos);
     225                size_t cur_size = str_nbytes(data + pos, total_size - pos);
    226226                if (((char *) data)[pos + cur_size] != 0)
    227227                        break;

  • uspace/lib/c/generic/task.c

    rd066259 r08e103d4  
    7575        assert(name);
    7676
    77         return (errno_t) __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_size(name));
     77        return (errno_t) __SYSCALL2(SYS_TASK_SET_NAME, (sysarg_t) name, str_bytes(name));
    7878}
    7979

  • uspace/lib/c/generic/thread/thread.c

    rd066259 r08e103d4  
    122122
    123123        errno_t rc = (errno_t) __SYSCALL4(SYS_THREAD_CREATE, (sysarg_t) uarg,
    124             (sysarg_t) name, (sysarg_t) str_size(name), (sysarg_t) tid);
     124            (sysarg_t) name, (sysarg_t) str_bytes(name), (sysarg_t) tid);
    125125
    126126        if (rc != EOK) {

  • uspace/lib/c/generic/tmpfile.c

    rd066259 r08e103d4  
    6262        errno_t rc;
    6363
    64         tsize = str_size(templ);
     64        tsize = str_bytes(templ);
    6565        if (tsize < 6)
    6666                return -1;

  • uspace/lib/c/generic/vfs/vfs.c

    rd066259 r08e103d4  
    181181
    182182        fibril_mutex_lock(&cwd_mutex);
    183         size_t size = str_size(path);
     183        size_t size = str_bytes(path);
    184184        if (*path != '/') {
    185185                if (cwd_path == NULL) {
    … …  
    382382
    383383        rc = async_data_write_start(exch, (void *) fs_name,
    384             str_size(fs_name));
     384            str_bytes(fs_name));
    385385
    386386        async_wait_for(req, &rc);
    … …  
    630630            &answer);
    631631
    632         rc1 = async_data_write_start(exch, (void *) opts, str_size(opts));
     632        rc1 = async_data_write_start(exch, (void *) opts, str_bytes(opts));
    633633        if (rc1 == EOK) {
    634634                rc1 = async_data_write_start(exch, (void *) fs_name,
    635                     str_size(fs_name));
     635                    str_bytes(fs_name));
    636636        }
    637637
    … …  
    11801180
    11811181        req = async_send_2(exch, VFS_IN_UNLINK, parent, expect, NULL);
    1182         rc = async_data_write_start(exch, child, str_size(child));
     1182        rc = async_data_write_start(exch, child, str_bytes(child));
    11831183
    11841184        vfs_exchange_end(exch);
    … …  
    12711271        ipc_call_t answer;
    12721272        aid_t req = async_send_2(exch, VFS_IN_WALK, parent, flags, &answer);
    1273         errno_t rc = async_data_write_start(exch, path, str_size(path));
     1273        errno_t rc = async_data_write_start(exch, path, str_bytes(path));
    12741274        vfs_exchange_end(exch);
    12751275

  • uspace/lib/c/generic/vol.c

    rd066259 r08e103d4  
    328328        aid_t req = async_send_0(exch, VOL_PART_INSERT_BY_PATH, &answer);
    329329
    330         retval = async_data_write_start(exch, path, str_size(path));
     330        retval = async_data_write_start(exch, path, str_bytes(path));
    331331        if (retval != EOK) {
    332332                async_exchange_end(exch);
    … …  
    395395        aid_t req = async_send_2(exch, VOL_PART_MKFS, sid, fstype, &answer);
    396396
    397         retval = async_data_write_start(exch, label, str_size(label));
     397        retval = async_data_write_start(exch, label, str_bytes(label));
    398398        if (retval != EOK) {
    399399                async_exchange_end(exch);
    … …  
    402402        }
    403403
    404         retval = async_data_write_start(exch, mountp, str_size(mountp));
     404        retval = async_data_write_start(exch, mountp, str_bytes(mountp));
    405405        if (retval != EOK) {
    406406                async_exchange_end(exch);
    … …  
    437437            &answer);
    438438
    439         retval = async_data_write_start(exch, mountp, str_size(mountp));
     439        retval = async_data_write_start(exch, mountp, str_bytes(mountp));
    440440        if (retval != EOK) {
    441441                async_exchange_end(exch);

  • uspace/lib/c/include/io/klog.h

    rd066259 r08e103d4  
    5151        errno_t _rc = ENOMEM; \
    5252        if (asprintf(&_s, fmt, ##__VA_ARGS__) >= 0) { \
    53                 _rc = klog_write((lvl), _s, str_size(_s)); \
     53                _rc = klog_write((lvl), _s, str_bytes(_s)); \
    5454                free(_s); \
    5555        }; \

  • uspace/lib/c/include/stdio.h

    rd066259 r08e103d4  
    204204};
    205205
    206 extern int vprintf_length(const char *, va_list);
    207 extern int printf_length(const char *, ...)
     206extern int vprintf_code_points(const char *, va_list);
     207extern int printf_code_points(const char *, ...)
    208208    _HELENOS_PRINTF_ATTRIBUTE(1, 2);
    209209extern FILE *fdopen(int, const char *);

  • uspace/lib/c/include/str.h

    rd066259 r08e103d4  
    6868extern errno_t chr_encode(wchar_t ch, char *str, size_t *offset, size_t sz);
    6969
    70 extern size_t str_size(const char *str);
    71 extern size_t wstr_size(const wchar_t *str);
     70extern size_t str_bytes(const char *str);
     71extern size_t wstr_bytes(const wchar_t *str);
    7272
    73 extern size_t str_nsize(const char *str, size_t max_size);
    74 extern size_t wstr_nsize(const wchar_t *str, size_t max_size);
     73extern size_t str_nbytes(const char *str, size_t max_size);
     74extern size_t wstr_nbytes(const wchar_t *str, size_t max_size);
    7575
    76 extern size_t str_lsize(const char *str, size_t max_len);
    77 extern size_t wstr_lsize(const wchar_t *str, size_t max_len);
     76extern size_t str_lbytes(const char *str, size_t max_len);
     77extern size_t wstr_lbytes(const wchar_t *str, size_t max_len);
    7878
    79 extern size_t str_length(const char *str);
    80 extern size_t wstr_length(const wchar_t *wstr);
     79extern size_t str_code_points(const char *str);
     80extern size_t wstr_code_points(const wchar_t *wstr);
    8181
    82 extern size_t str_nlength(const char *str, size_t size);
    83 extern size_t wstr_nlength(const wchar_t *str, size_t size);
     82extern size_t str_ncode_points(const char *str, size_t size);
     83extern size_t wstr_ncode_points(const wchar_t *str, size_t size);
    8484
    8585extern size_t chr_width(wchar_t ch);
Note: See TracChangeset for help on using the changeset viewer.