Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 06b785f in mainline


Ignore:
Timestamp:
2009-04-01T19:11:07Z (13 years ago)
Author:
Jiri Svoboda <jirik.svoboda@…>
Branches:
lfn, master
Children:
d09f84e6
Parents:
1b0b48e0
Message:

strlen() → str_size().

Location:
kernel
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • kernel/genarch/src/multiboot/multiboot.c

    r1b0b48e0 r06b785f  
    5555        end = strchr(cmd_line, ' ');
    5656        if (end == NULL)
    57                 end = cmd_line + strlen(cmd_line);
     57                end = cmd_line + str_size(cmd_line);
    5858       
    5959        /*
  • kernel/genarch/src/ofw/ofw_tree.c

    r1b0b48e0 r06b785f  
    253253                return NULL;
    254254       
    255         for (i = 1; i < strlen(path) && node; i = j + 1) {
    256                 for (j = i; j < strlen(path) && path[j] != '/'; j++)
     255        for (i = 1; i < str_size(path) && node; i = j + 1) {
     256                for (j = i; j < str_size(path) && path[j] != '/'; j++)
    257257                        ;
    258258                if (i == j)     /* skip extra slashes */
  • kernel/generic/include/string.h

    r1b0b48e0 r06b785f  
    4444extern wchar_t chr_decode(const char *, size_t *, size_t);
    4545extern bool chr_encode(const wchar_t, char *, size_t *, size_t);
     46
     47extern size_t str_size(const char *str);
    4648extern size_t str_lsize(const char *, count_t);
     49extern count_t str_length(const char *str);
     50extern count_t wstr_length(const wchar_t *str);
     51
    4752extern bool ascii_check(const wchar_t ch);
    4853extern bool unicode_check(const wchar_t ch);
    49 
    50 extern size_t strlen(const char *str);
    51 extern count_t str_length(const char *str);
    52 extern count_t wstr_length(const wchar_t *str);
    5354
    5455extern int strcmp(const char *src, const char *dst);
  • kernel/generic/src/console/cmd.c

    r1b0b48e0 r06b785f  
    520520               
    521521                spinlock_lock(&hlp->lock);
    522                 if (strlen(hlp->name) > len)
    523                         len = strlen(hlp->name);
     522                if (str_size(hlp->name) > len)
     523                        len = str_size(hlp->name);
    524524                spinlock_unlock(&hlp->lock);
    525525        }
     
    592592                spinlock_lock(&hlp->lock);
    593593
    594                 if (strncmp(hlp->name, (const char *) argv->buffer, strlen(hlp->name)) == 0) {
     594                if (strncmp(hlp->name, (const char *) argv->buffer, str_size(hlp->name)) == 0) {
    595595                        printf("%s - %s\n", hlp->name, hlp->description);
    596596                        if (hlp->help)
     
    973973        test_t *test;
    974974        for (test = tests; test->name != NULL; test++) {
    975                 if (strlen(test->name) > len)
    976                         len = strlen(test->name);
     975                if (str_size(test->name) > len)
     976                        len = str_size(test->name);
    977977        }
    978978       
  • kernel/generic/src/console/kconsole.c

    r1b0b48e0 r06b785f  
    138138                        spinlock_lock(&hlp->lock);
    139139                }
    140                 if ((strncmp(hlp->name, cmd->name, max(strlen(cmd->name),
    141                     strlen(hlp->name))) == 0)) {
     140                if ((strncmp(hlp->name, cmd->name, max(str_size(cmd->name),
     141                    str_size(hlp->name))) == 0)) {
    142142                        /* The command is already there. */
    143143                        spinlock_unlock(&hlp->lock);
     
    173173        int i;
    174174       
    175         for (i = strlen(str); i > pos; i--)
     175        for (i = str_size(str); i > pos; i--)
    176176                str[i] = str[i - 1];
    177177        str[pos] = ch;
     
    181181static const char *cmdtab_search_one(const char *name,link_t **startpos)
    182182{
    183         size_t namelen = strlen(name);
     183        size_t namelen = str_size(name);
    184184        const char *curname;
    185185
     
    194194
    195195                curname = hlp->name;
    196                 if (strlen(curname) < namelen)
     196                if (str_size(curname) < namelen)
    197197                        continue;
    198198                if (strncmp(curname, name, namelen) == 0) {
     
    223223                startpos = startpos->next;
    224224                if (!found)
    225                         strncpy(output, foundtxt, strlen(foundtxt) + 1);
     225                        strncpy(output, foundtxt, str_size(foundtxt) + 1);
    226226                else {
    227227                        for (i = 0; output[i] && foundtxt[i] &&
     
    235235                return 0;
    236236
    237         if (found > 1 && !strlen(output)) {
     237        if (found > 1 && !str_size(output)) {
    238238                printf("\n");
    239239                startpos = NULL;
     
    310310                                insert_char(current, tmp[i], i + position);
    311311
    312                         if (strlen(tmp) || found == 1) { /* If we have a hint */
     312                        if (str_size(tmp) || found == 1) { /* If we have a hint */
    313313                                for (i = position; i < curlen; i++)
    314314                                        putchar(current[i]);
    315                                 position += strlen(tmp);
     315                                position += str_size(tmp);
    316316                                /* Add space to end */
    317317                                if (found == 1 && position == curlen &&
     
    326326                                for (i = 0; i < curlen; i++)
    327327                                        putchar(current[i]);
    328                                 position += strlen(tmp);
     328                                position += str_size(tmp);
    329329                        }
    330330                        rdln_print_c('\b', curlen - position);
     
    385385                                current = history[histposition];
    386386                                printf("%s", current);
    387                                 curlen = strlen(current);
     387                                curlen = str_size(current);
    388388                                position = curlen;
    389389                                continue;
     
    444444        while (true) {
    445445                cmdline = clever_readline((char *) prompt, stdin);
    446                 len = strlen(cmdline);
     446                len = str_size(cmdline);
    447447                if (!len)
    448448                        continue;
     
    545545                spinlock_lock(&hlp->lock);
    546546               
    547                 if (strncmp(hlp->name, &cmdline[start], max(strlen(hlp->name),
     547                if (strncmp(hlp->name, &cmdline[start], max(str_size(hlp->name),
    548548                    end - start + 1)) == 0) {
    549549                        cmd = hlp;
  • kernel/generic/src/debug/symtab.c

    r1b0b48e0 r06b785f  
    107107static char * symtab_search_one(const char *name, int *startpos)
    108108{
    109         unsigned int namelen = strlen(name);
     109        unsigned int namelen = str_size(name);
    110110        char *curname;
    111111        int i, j;
     
    127127                j -= colonoffset;
    128128                curname += j;
    129                 if (strlen(curname) < namelen)
     129                if (str_size(curname) < namelen)
    130130                        continue;
    131131                if (strncmp(curname, name, namelen) == 0) {
     
    158158        i = 0;
    159159        while ((hint = symtab_search_one(name, &i))) {
    160                 if (!strlen(hint)) {
     160                if (!str_size(hint)) {
    161161                        *addr =  uint64_t_le2host(symbol_table[i].address_le);
    162162                        found++;
     
    215215
    216216        /* Do not print everything */
    217         if (!strlen(name))
     217        if (!str_size(name))
    218218                return 0;
    219219       
     
    224224                startpos++;
    225225                if (!found)
    226                         strncpy(output, foundtxt, strlen(foundtxt) + 1);
     226                        strncpy(output, foundtxt, str_size(foundtxt) + 1);
    227227                else {
    228228                        for (i = 0; output[i] && foundtxt[i] &&
     
    236236                return 0;
    237237
    238         if (found > 1 && !strlen(output)) {
     238        if (found > 1 && !str_size(output)) {
    239239                printf("\n");
    240240                startpos = 0;
  • kernel/generic/src/lib/string.c

    r1b0b48e0 r06b785f  
    7070 *
    7171 * @return      Value of decoded character or '?' on decoding error.
    72  *
    7372 */
    7473wchar_t chr_decode(const char *str, size_t *offset, size_t sz)
     
    247246 *
    248247 * @return True if character is valid Unicode code point.
    249  *
    250248 */
    251249bool unicode_check(const wchar_t ch)
     
    257255}
    258256
    259 /** Return number of plain characters in a string.
    260  *
    261  * @param str NULL-terminated string.
    262  *
    263  * @return Number of characters in @a str.
    264  *
    265  */
    266 size_t strlen(const char *str)
     257/** Return number of bytes the string occupies.
     258 *
     259 * @param str A string.
     260 * @return Number of bytes in @a str excluding the null terminator.
     261 */
     262size_t str_size(const char *str)
    267263{
    268264        size_t size;
    269         for (size = 0; str[size]; size++);
    270        
     265
     266        size = 0;
     267        while (*str++ != '\0')
     268                ++size;
     269
    271270        return size;
    272271}
     
    347346 *
    348347 * @return 0 if the strings are equal, -1 if first is smaller, 1 if second smaller.
    349  *
    350348 */
    351349int strncmp(const char *src, const char *dst, size_t len)
     
    381379 * @param dest Destination buffer.
    382380 * @param len  Size of destination buffer.
    383  *
    384381 */
    385382void strncpy(char *dest, const char *src, size_t len)
  • kernel/generic/src/printf/printf_core.c

    r1b0b48e0 r06b785f  
    126126{
    127127        if (str == NULL)
    128                 return printf_putnchars_utf8(nullstr, strlen(nullstr), ps);
    129        
    130         return ps->write_utf8((void *) str, strlen(str), ps->data);
     128                return printf_putnchars_utf8(nullstr, str_size(nullstr), ps);
     129       
     130        return ps->write_utf8((void *) str, str_size(str), ps->data);
    131131}
    132132
Note: See TracChangeset for help on using the changeset viewer.