Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r28a5ebd r1c9bf292  
    4242 * strings, called just strings are encoded in UTF-8. Wide strings (encoded
    4343 * in UTF-32) are supported to a limited degree. A single character is
    44  * represented as char32_t.@n
     44 * represented as wchar_t.@n
    4545 *
    4646 * Overview of the terminology:@n
    … …  
    5050 *  byte                  8 bits stored in uint8_t (unsigned 8 bit integer)
    5151 *
    52  *  character             UTF-32 encoded Unicode character, stored in char32_t
    53  *                        (unsigned 32 bit integer), code points 0 .. 1114111
     52 *  character             UTF-32 encoded Unicode character, stored in wchar_t
     53 *                        (signed 32 bit integer), code points 0 .. 1114111
    5454 *                        are valid
    5555 *
    … …  
    6161 *
    6262 *  wide string           UTF-32 encoded NULL-terminated Unicode string,
    63  *                        char32_t *
     63 *                        wchar_t *
    6464 *
    6565 *  [wide] string size    number of BYTES in a [wide] string (excluding
    … …  
    100100 * A specific character inside a [wide] string can be referred to by:@n
    101101 *
    102  *  pointer (char *, char32_t *)
     102 *  pointer (char *, wchar_t *)
    103103 *  byte offset (size_t)
    104104 *  character index (size_t)
    … …  
    119119#include <mem.h>
    120120
     121/** Check the condition if wchar_t is signed */
     122#ifdef __WCHAR_UNSIGNED__
     123#define WCHAR_SIGNED_CHECK(cond)  (true)
     124#else
     125#define WCHAR_SIGNED_CHECK(cond)  (cond)
     126#endif
     127
    121128/** Byte mask consisting of lowest @n bits (out of 8) */
    122129#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
    … …  
    146153 *
    147154 */
    148 char32_t str_decode(const char *str, size_t *offset, size_t size)
     155wchar_t str_decode(const char *str, size_t *offset, size_t size)
    149156{
    150157        if (*offset + 1 > size)
    … …  
    183190                return U_SPECIAL;
    184191
    185         char32_t ch = b0 & LO_MASK_8(b0_bits);
     192        wchar_t ch = b0 & LO_MASK_8(b0_bits);
    186193
    187194        /* Decode continuation bytes */
    … …  
    194201
    195202                /* Shift data bits to ch */
    196                 ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
     203                ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
    197204                cbytes--;
    198205        }
    … …  
    216223 *
    217224 */
    218 char32_t str_decode_reverse(const char *str, size_t *offset, size_t size)
     225wchar_t str_decode_reverse(const char *str, size_t *offset, size_t size)
    219226{
    220227        if (*offset == 0)
    … …  
    259266 *         code was invalid.
    260267 */
    261 errno_t chr_encode(const char32_t ch, char *str, size_t *offset, size_t size)
     268errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
    262269{
    263270        if (*offset >= size)
    … …  
    345352 *
    346353 */
    347 size_t wstr_size(const char32_t *str)
    348 {
    349         return (wstr_length(str) * sizeof(char32_t));
     354size_t wstr_size(const wchar_t *str)
     355{
     356        return (wstr_length(str) * sizeof(wchar_t));
    350357}
    351358
    … …  
    410417 *
    411418 */
    412 size_t wstr_nsize(const char32_t *str, size_t max_size)
    413 {
    414         return (wstr_nlength(str, max_size) * sizeof(char32_t));
     419size_t wstr_nsize(const wchar_t *str, size_t max_size)
     420{
     421        return (wstr_nlength(str, max_size) * sizeof(wchar_t));
    415422}
    416423
    … …  
    428435 *
    429436 */
    430 size_t wstr_lsize(const char32_t *str, size_t max_len)
    431 {
    432         return (wstr_nlength(str, max_len * sizeof(char32_t)) * sizeof(char32_t));
     437size_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));
    433440}
    434441
    … …  
    458465 *
    459466 */
    460 size_t wstr_length(const char32_t *wstr)
     467size_t wstr_length(const wchar_t *wstr)
    461468{
    462469        size_t len = 0;
    … …  
    495502 *
    496503 */
    497 size_t wstr_nlength(const char32_t *str, size_t size)
     504size_t wstr_nlength(const wchar_t *str, size_t size)
    498505{
    499506        size_t len = 0;
    500         size_t limit = ALIGN_DOWN(size, sizeof(char32_t));
     507        size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
    501508        size_t offset = 0;
    502509
    503510        while ((offset < limit) && (*str++ != 0)) {
    504511                len++;
    505                 offset += sizeof(char32_t);
     512                offset += sizeof(wchar_t);
    506513        }
    507514
    … …  
    514521 * @return      Width of character in cells.
    515522 */
    516 size_t chr_width(char32_t ch)
     523size_t chr_width(wchar_t ch)
    517524{
    518525        return 1;
    … …  
    528535        size_t width = 0;
    529536        size_t offset = 0;
    530         char32_t ch;
     537        wchar_t ch;
    531538
    532539        while ((ch = str_decode(str, &offset, STR_NO_LIMIT)) != 0)
    … …  
    541548 *
    542549 */
    543 bool ascii_check(char32_t ch)
    544 {
    545         if (ch <= 127)
     550bool ascii_check(wchar_t ch)
     551{
     552        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    546553                return true;
    547554
    … …  
    554561 *
    555562 */
    556 bool chr_check(char32_t ch)
    557 {
    558         if (ch <= 1114111)
     563bool chr_check(wchar_t ch)
     564{
     565        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    559566                return true;
    560567
    … …  
    582589int str_cmp(const char *s1, const char *s2)
    583590{
    584         char32_t c1 = 0;
    585         char32_t c2 = 0;
     591        wchar_t c1 = 0;
     592        wchar_t c2 = 0;
    586593
    587594        size_t off1 = 0;
    … …  
    629636int str_lcmp(const char *s1, const char *s2, size_t max_len)
    630637{
    631         char32_t c1 = 0;
    632         char32_t c2 = 0;
     638        wchar_t c1 = 0;
     639        wchar_t c2 = 0;
    633640
    634641        size_t off1 = 0;
    … …  
    681688int str_casecmp(const char *s1, const char *s2)
    682689{
    683         char32_t c1 = 0;
    684         char32_t c2 = 0;
     690        wchar_t c1 = 0;
     691        wchar_t c2 = 0;
    685692
    686693        size_t off1 = 0;
    … …  
    729736int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
    730737{
    731         char32_t c1 = 0;
    732         char32_t c2 = 0;
     738        wchar_t c1 = 0;
     739        wchar_t c2 = 0;
    733740
    734741        size_t off1 = 0;
    … …  
    773780bool str_test_prefix(const char *s, const char *p)
    774781{
    775         char32_t c1 = 0;
    776         char32_t c2 = 0;
     782        wchar_t c1 = 0;
     783        wchar_t c2 = 0;
    777784
    778785        size_t off1 = 0;
    … …  
    794801
    795802        return false;
    796 }
    797 
    798 /** Get a string suffix.
    799  *
    800  * Return a string suffix defined by the prefix length.
    801  *
    802  * @param s             The string to get the suffix from.
    803  * @param prefix_length Number of prefix characters to ignore.
    804  *
    805  * @return String suffix.
    806  *
    807  */
    808 const char *str_suffix(const char *s, size_t prefix_length)
    809 {
    810         size_t off = 0;
    811         size_t i = 0;
    812 
    813         while (true) {
    814                 str_decode(s, &off, STR_NO_LIMIT);
    815                 i++;
    816 
    817                 if (i >= prefix_length)
    818                         break;
    819         }
    820 
    821         return s + off;
    822803}
    823804
    … …  
    843824        size_t dest_off = 0;
    844825
    845         char32_t ch;
     826        wchar_t ch;
    846827        while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
    847828                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    876857        size_t dest_off = 0;
    877858
    878         char32_t ch;
     859        wchar_t ch;
    879860        while ((ch = str_decode(src, &src_off, n)) != 0) {
    880861                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    980961 * @param src   Source wide string.
    981962 */
    982 void wstr_to_str(char *dest, size_t size, const char32_t *src)
    983 {
    984         char32_t ch;
     963void wstr_to_str(char *dest, size_t size, const wchar_t *src)
     964{
     965        wchar_t ch;
    985966        size_t src_idx;
    986967        size_t dest_off;
    … …  
    1015996{
    1016997        size_t idx = 0, dest_off = 0;
    1017         char32_t ch;
     998        wchar_t ch;
    1018999        errno_t rc = EOK;
    10191000
    … …  
    10591040        size_t offset = 0;
    10601041        size_t idx = 0;
    1061         char32_t c;
     1042        wchar_t c;
    10621043
    10631044        assert(dlen > 0);
    … …  
    11161097 * @return      New string.
    11171098 */
    1118 char *wstr_to_astr(const char32_t *src)
     1099char *wstr_to_astr(const wchar_t *src)
    11191100{
    11201101        char dbuf[STR_BOUNDS(1)];
    11211102        char *str;
    1122         char32_t ch;
     1103        wchar_t ch;
    11231104
    11241105        size_t src_idx;
    … …  
    11661147 * @param src   Source string.
    11671148 */
    1168 void str_to_wstr(char32_t *dest, size_t dlen, const char *src)
     1149void str_to_wstr(wchar_t *dest, size_t dlen, const char *src)
    11691150{
    11701151        size_t offset;
    11711152        size_t di;
    1172         char32_t c;
     1153        wchar_t c;
    11731154
    11741155        assert(dlen > 0);
    … …  
    11951176 * @param src   Source string.
    11961177 */
    1197 char32_t *str_to_awstr(const char *str)
     1178wchar_t *str_to_awstr(const char *str)
    11981179{
    11991180        size_t len = str_length(str);
    12001181
    1201         char32_t *wstr = calloc(len + 1, sizeof(char32_t));
     1182        wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
    12021183        if (wstr == NULL)
    12031184                return NULL;
    … …  
    12141195 * @return Pointer to character in @a str or NULL if not found.
    12151196 */
    1216 char *str_chr(const char *str, char32_t ch)
    1217 {
    1218         char32_t acc;
     1197char *str_chr(const char *str, wchar_t ch)
     1198{
     1199        wchar_t acc;
    12191200        size_t off = 0;
    12201201        size_t last = 0;
    … …  
    12561237 * @param ch  Character to remove.
    12571238 */
    1258 void str_rtrim(char *str, char32_t ch)
     1239void str_rtrim(char *str, wchar_t ch)
    12591240{
    12601241        size_t off = 0;
    12611242        size_t pos = 0;
    1262         char32_t c;
     1243        wchar_t c;
    12631244        bool update_last_chunk = true;
    12641245        char *last_chunk = NULL;
    … …  
    12841265 * @param ch  Character to remove.
    12851266 */
    1286 void str_ltrim(char *str, char32_t ch)
    1287 {
    1288         char32_t acc;
     1267void str_ltrim(char *str, wchar_t ch)
     1268{
     1269        wchar_t acc;
    12891270        size_t off = 0;
    12901271        size_t pos = 0;
    … …  
    13121293 * @return Pointer to character in @a str or NULL if not found.
    13131294 */
    1314 char *str_rchr(const char *str, char32_t ch)
    1315 {
    1316         char32_t acc;
     1295char *str_rchr(const char *str, wchar_t ch)
     1296{
     1297        wchar_t acc;
    13171298        size_t off = 0;
    13181299        size_t last = 0;
    … …  
    13421323 *
    13431324 */
    1344 bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos)
     1325bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
    13451326{
    13461327        size_t len = wstr_length(str);
    … …  
    13701351 *
    13711352 */
    1372 bool wstr_remove(char32_t *str, size_t pos)
     1353bool wstr_remove(wchar_t *str, size_t pos)
    13731354{
    13741355        size_t len = wstr_length(str);
    … …  
    14671448        size_t cur;
    14681449        size_t tmp;
    1469         char32_t ch;
     1450        wchar_t ch;
    14701451
    14711452        /* Skip over leading delimiters. */
Note: See TracChangeset for help on using the changeset viewer.