Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r28a5ebd r42e91ae  
    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)
    … …  
    118118#include <macros.h>
    119119
     120/** Check the condition if wchar_t is signed */
     121#ifdef __WCHAR_UNSIGNED__
     122#define WCHAR_SIGNED_CHECK(cond)  (true)
     123#else
     124#define WCHAR_SIGNED_CHECK(cond)  (cond)
     125#endif
     126
    120127/** Byte mask consisting of lowest @n bits (out of 8) */
    121128#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
    … …  
    145152 *
    146153 */
    147 char32_t str_decode(const char *str, size_t *offset, size_t size)
     154wchar_t str_decode(const char *str, size_t *offset, size_t size)
    148155{
    149156        if (*offset + 1 > size)
    … …  
    182189                return U_SPECIAL;
    183190
    184         char32_t ch = b0 & LO_MASK_8(b0_bits);
     191        wchar_t ch = b0 & LO_MASK_8(b0_bits);
    185192
    186193        /* Decode continuation bytes */
    … …  
    193200
    194201                /* Shift data bits to ch */
    195                 ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
     202                ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
    196203                cbytes--;
    197204        }
    … …  
    215222 *         code was invalid.
    216223 */
    217 errno_t chr_encode(const char32_t ch, char *str, size_t *offset, size_t size)
     224errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
    218225{
    219226        if (*offset >= size)
    … …  
    301308 *
    302309 */
    303 size_t wstr_size(const char32_t *str)
    304 {
    305         return (wstr_length(str) * sizeof(char32_t));
     310size_t wstr_size(const wchar_t *str)
     311{
     312        return (wstr_length(str) * sizeof(wchar_t));
    306313}
    307314
    … …  
    347354 *
    348355 */
    349 size_t wstr_lsize(const char32_t *str, size_t max_len)
    350 {
    351         return (wstr_nlength(str, max_len * sizeof(char32_t)) * sizeof(char32_t));
     356size_t wstr_lsize(const wchar_t *str, size_t max_len)
     357{
     358        return (wstr_nlength(str, max_len * sizeof(wchar_t)) * sizeof(wchar_t));
    352359}
    353360
    … …  
    377384 *
    378385 */
    379 size_t wstr_length(const char32_t *wstr)
     386size_t wstr_length(const wchar_t *wstr)
    380387{
    381388        size_t len = 0;
    … …  
    414421 *
    415422 */
    416 size_t wstr_nlength(const char32_t *str, size_t size)
     423size_t wstr_nlength(const wchar_t *str, size_t size)
    417424{
    418425        size_t len = 0;
    419         size_t limit = ALIGN_DOWN(size, sizeof(char32_t));
     426        size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
    420427        size_t offset = 0;
    421428
    422429        while ((offset < limit) && (*str++ != 0)) {
    423430                len++;
    424                 offset += sizeof(char32_t);
     431                offset += sizeof(wchar_t);
    425432        }
    426433
    … …  
    433440 *
    434441 */
    435 bool ascii_check(char32_t ch)
    436 {
    437         if (ch <= 127)
     442bool ascii_check(wchar_t ch)
     443{
     444        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
    438445                return true;
    439446
    … …  
    446453 *
    447454 */
    448 bool chr_check(char32_t ch)
    449 {
    450         if (ch <= 1114111)
     455bool chr_check(wchar_t ch)
     456{
     457        if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
    451458                return true;
    452459
    … …  
    474481int str_cmp(const char *s1, const char *s2)
    475482{
    476         char32_t c1 = 0;
    477         char32_t c2 = 0;
     483        wchar_t c1 = 0;
     484        wchar_t c2 = 0;
    478485
    479486        size_t off1 = 0;
    … …  
    521528int str_lcmp(const char *s1, const char *s2, size_t max_len)
    522529{
    523         char32_t c1 = 0;
    524         char32_t c2 = 0;
     530        wchar_t c1 = 0;
     531        wchar_t c2 = 0;
    525532
    526533        size_t off1 = 0;
    … …  
    573580        size_t dest_off = 0;
    574581
    575         char32_t ch;
     582        wchar_t ch;
    576583        while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
    577584                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    606613        size_t dest_off = 0;
    607614
    608         char32_t ch;
     615        wchar_t ch;
    609616        while ((ch = str_decode(src, &src_off, n)) != 0) {
    610617                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    621628 * written will always be well-formed.
    622629 *
    623  * @param dest Destination buffer.
    624  * @param size Size of the destination buffer.
    625  * @param src  Source wide string.
    626  */
    627 void wstr_to_str(char *dest, size_t size, const char32_t *src)
    628 {
    629         char32_t ch;
     630 * @param dest  Destination buffer.
     631 * @param size  Size of the destination buffer.
     632 * @param src   Source wide string.
     633 */
     634void wstr_to_str(char *dest, size_t size, const wchar_t *src)
     635{
     636        wchar_t ch;
    630637        size_t src_idx;
    631638        size_t dest_off;
    … …  
    652659 * @return Pointer to character in @a str or NULL if not found.
    653660 */
    654 char *str_chr(const char *str, char32_t ch)
    655 {
    656         char32_t acc;
     661char *str_chr(const char *str, wchar_t ch)
     662{
     663        wchar_t acc;
    657664        size_t off = 0;
    658665        size_t last = 0;
    … …  
    681688 *
    682689 */
    683 bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos)
     690bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
    684691{
    685692        size_t len = wstr_length(str);
    … …  
    709716 *
    710717 */
    711 bool wstr_remove(char32_t *str, size_t pos)
     718bool wstr_remove(wchar_t *str, size_t pos)
    712719{
    713720        size_t len = wstr_length(str);
Note: See TracChangeset for help on using the changeset viewer.