Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/lib/str.c

    ra35b458 r1b20da0  
    151151        if (*offset + 1 > size)
    152152                return 0;
    153 
     153       
    154154        /* First byte read from string */
    155155        uint8_t b0 = (uint8_t) str[(*offset)++];
    156 
     156       
    157157        /* Determine code length */
    158 
     158       
    159159        unsigned int b0_bits;  /* Data bits in first byte */
    160160        unsigned int cbytes;   /* Number of continuation bytes */
    161 
     161       
    162162        if ((b0 & 0x80) == 0) {
    163163                /* 0xxxxxxx (Plain ASCII) */
    … …  
    180180                return U_SPECIAL;
    181181        }
    182 
     182       
    183183        if (*offset + cbytes > size)
    184184                return U_SPECIAL;
    185 
     185       
    186186        wchar_t ch = b0 & LO_MASK_8(b0_bits);
    187 
     187       
    188188        /* Decode continuation bytes */
    189189        while (cbytes > 0) {
    190190                uint8_t b = (uint8_t) str[(*offset)++];
    191 
     191               
    192192                /* Must be 10xxxxxx */
    193193                if ((b & 0xc0) != 0x80)
    194194                        return U_SPECIAL;
    195 
     195               
    196196                /* Shift data bits to ch */
    197197                ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
    198198                cbytes--;
    199199        }
    200 
     200       
    201201        return ch;
    202202}
    … …  
    221221        if (*offset >= size)
    222222                return EOVERFLOW;
    223 
     223       
    224224        if (!chr_check(ch))
    225225                return EINVAL;
    226 
     226       
    227227        /* Unsigned version of ch (bit operations should only be done
    228228           on unsigned types). */
    229229        uint32_t cc = (uint32_t) ch;
    230 
     230       
    231231        /* Determine how many continuation bytes are needed */
    232 
     232       
    233233        unsigned int b0_bits;  /* Data bits in first byte */
    234234        unsigned int cbytes;   /* Number of continuation bytes */
    235 
     235       
    236236        if ((cc & ~LO_MASK_32(7)) == 0) {
    237237                b0_bits = 7;
    … …  
    250250                return EINVAL;
    251251        }
    252 
     252       
    253253        /* Check for available space in buffer */
    254254        if (*offset + cbytes >= size)
    255255                return EOVERFLOW;
    256 
     256       
    257257        /* Encode continuation bytes */
    258258        unsigned int i;
    … …  
    261261                cc = cc >> CONT_BITS;
    262262        }
    263 
     263       
    264264        /* Encode first byte */
    265265        str[*offset] = (cc & LO_MASK_32(b0_bits)) | HI_MASK_8(8 - b0_bits - 1);
    266 
     266       
    267267        /* Advance offset */
    268268        *offset += cbytes + 1;
    269 
     269       
    270270        return EOK;
    271271}
    … …  
    284284{
    285285        size_t size = 0;
    286 
     286       
    287287        while (*str++ != 0)
    288288                size++;
    289 
     289       
    290290        return size;
    291291}
    … …  
    323323        size_t len = 0;
    324324        size_t offset = 0;
    325 
     325       
    326326        while (len < max_len) {
    327327                if (str_decode(str, &offset, STR_NO_LIMIT) == 0)
    328328                        break;
    329 
     329               
    330330                len++;
    331331        }
    332 
     332       
    333333        return offset;
    334334}
    … …  
    363363        size_t len = 0;
    364364        size_t offset = 0;
    365 
     365       
    366366        while (str_decode(str, &offset, STR_NO_LIMIT) != 0)
    367367                len++;
    368 
     368       
    369369        return len;
    370370}
    … …  
    380380{
    381381        size_t len = 0;
    382 
     382       
    383383        while (*wstr++ != 0)
    384384                len++;
    385 
     385       
    386386        return len;
    387387}
    … …  
    399399        size_t len = 0;
    400400        size_t offset = 0;
    401 
     401       
    402402        while (str_decode(str, &offset, size) != 0)
    403403                len++;
    404 
     404       
    405405        return len;
    406406}
    … …  
    419419        size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
    420420        size_t offset = 0;
    421 
     421       
    422422        while ((offset < limit) && (*str++ != 0)) {
    423423                len++;
    424424                offset += sizeof(wchar_t);
    425425        }
    426 
     426       
    427427        return len;
    428428}
    … …  
    437437        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    438438                return true;
    439 
     439       
    440440        return false;
    441441}
    … …  
    450450        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    451451                return true;
    452 
     452       
    453453        return false;
    454454}
    … …  
    476476        wchar_t c1 = 0;
    477477        wchar_t c2 = 0;
    478 
     478       
    479479        size_t off1 = 0;
    480480        size_t off2 = 0;
    … …  
    486486                if (c1 < c2)
    487487                        return -1;
    488 
     488               
    489489                if (c1 > c2)
    490490                        return 1;
    … …  
    523523        wchar_t c1 = 0;
    524524        wchar_t c2 = 0;
    525 
     525       
    526526        size_t off1 = 0;
    527527        size_t off2 = 0;
    528 
     528       
    529529        size_t len = 0;
    530530
    … …  
    569569        assert(size > 0);
    570570        assert(src != NULL);
    571 
     571       
    572572        size_t src_off = 0;
    573573        size_t dest_off = 0;
    574 
     574       
    575575        wchar_t ch;
    576576        while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
    … …  
    578578                        break;
    579579        }
    580 
     580       
    581581        dest[dest_off] = '\0';
    582582}
    … …  
    602602        /* There must be space for a null terminator in the buffer. */
    603603        assert(size > 0);
    604 
     604       
    605605        size_t src_off = 0;
    606606        size_t dest_off = 0;
    607 
     607       
    608608        wchar_t ch;
    609609        while ((ch = str_decode(src, &src_off, n)) != 0) {
    … …  
    611611                        break;
    612612        }
    613 
     613       
    614614        dest[dest_off] = '\0';
    615615}
    … …  
    636636        char *dest = malloc(size, 0);
    637637        assert(dest);
    638 
     638       
    639639        str_cpy(dest, size, src);
    640640        return dest;
    … …  
    666666        if (size > n)
    667667                size = n;
    668 
     668       
    669669        char *dest = malloc(size + 1, 0);
    670670        assert(dest);
    671 
     671       
    672672        str_ncpy(dest, size + 1, src, size);
    673673        return dest;
    … …  
    695695        src_idx = 0;
    696696        dest_off = 0;
    697 
     697       
    698698        while ((ch = src[src_idx++]) != 0) {
    699699                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    717717        size_t off = 0;
    718718        size_t last = 0;
    719 
     719       
    720720        while ((acc = str_decode(str, &off, STR_NO_LIMIT)) != 0) {
    721721                if (acc == ch)
    … …  
    723723                last = off;
    724724        }
    725 
     725       
    726726        return NULL;
    727727}
    … …  
    744744{
    745745        size_t len = wstr_length(str);
    746 
     746       
    747747        if ((pos > len) || (pos + 1 > max_pos))
    748748                return false;
    749 
     749       
    750750        size_t i;
    751751        for (i = len; i + 1 > pos; i--)
    752752                str[i + 1] = str[i];
    753 
     753       
    754754        str[pos] = ch;
    755 
     755       
    756756        return true;
    757757}
    … …  
    772772{
    773773        size_t len = wstr_length(str);
    774 
     774       
    775775        if (pos >= len)
    776776                return false;
    777 
     777       
    778778        size_t i;
    779779        for (i = pos + 1; i <= len; i++)
    780780                str[i - 1] = str[i];
    781 
     781       
    782782        return true;
    783783}
    … …  
    800800        assert(neg != NULL);
    801801        assert(result != NULL);
    802 
     802       
    803803        *neg = false;
    804804        const char *str = nptr;
    805 
     805       
    806806        /* Ignore leading whitespace */
    807807        while (isspace(*str))
    808808                str++;
    809 
     809       
    810810        if (*str == '-') {
    811811                *neg = true;
    … …  
    813813        } else if (*str == '+')
    814814                str++;
    815 
     815       
    816816        if (base == 0) {
    817817                /* Decode base if not specified */
    818818                base = 10;
    819 
     819               
    820820                if (*str == '0') {
    821821                        base = 8;
    822822                        str++;
    823 
     823                       
    824824                        switch (*str) {
    825825                        case 'b':
    … …  
    856856                }
    857857        }
    858 
     858       
    859859        *result = 0;
    860860        const char *startstr = str;
    861 
     861       
    862862        while (*str != 0) {
    863863                unsigned int digit;
    864 
     864               
    865865                if ((*str >= 'a') && (*str <= 'z'))
    866866                        digit = *str - 'a' + 10;
    … …  
    871871                else
    872872                        break;
    873 
     873               
    874874                if (digit >= base)
    875875                        break;
    876 
     876               
    877877                uint64_t prev = *result;
    878878                *result = (*result) * base + digit;
    879 
     879               
    880880                if (*result < prev) {
    881881                        /* Overflow */
    … …  
    883883                        return EOVERFLOW;
    884884                }
    885 
     885               
    886886                str++;
    887887        }
    888 
     888       
    889889        if (str == startstr) {
    890890                /*
    … …  
    894894                str = nptr;
    895895        }
    896 
     896       
    897897        *endptr = (char *) str;
    898 
     898       
    899899        if (str == nptr)
    900900                return EINVAL;
    901 
     901       
    902902        return EOK;
    903903}
    … …  
    919919{
    920920        assert(result != NULL);
    921 
     921       
    922922        bool neg;
    923923        char *lendptr;
    924924        errno_t ret = str_uint(nptr, &lendptr, base, &neg, result);
    925 
     925       
    926926        if (endptr != NULL)
    927927                *endptr = (char *) lendptr;
    928 
     928       
    929929        if (ret != EOK)
    930930                return ret;
    931 
     931       
    932932        /* Do not allow negative values */
    933933        if (neg)
    934934                return EINVAL;
    935 
     935       
    936936        /* Check whether we are at the end of
    937937           the string in strict mode */
    938938        if ((strict) && (*lendptr != 0))
    939939                return EINVAL;
    940 
     940       
    941941        return EOK;
    942942}
Note: See TracChangeset for help on using the changeset viewer.