Changeset 28a5ebd in mainline for uspace/lib/c/generic


Ignore:
Timestamp:
2020-06-18T15:39:50Z (5 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
ce52c333
Parents:
4f663f3e
Message:

Use char32_t instead of wchat_t to represent UTF-32 strings

The intention of the native HelenOS string API has been always to
support Unicode in the UTF-8 and UTF-32 encodings as the sole character
representations and ignore the obsolete mess of older single-byte and
multibyte character encodings. Before C11, the wchar_t type has been
slightly misused for the purpose of the UTF-32 strings. The newer
char32_t type is obviously a much more suitable option. The standard
defines char32_t as uint_least32_t, thus we can take the liberty to fix
it to uint32_t.

To maintain compatilibity with the C Standard, the putwchar(wchar_t)
functions has been replaced by our custom putuchar(char32_t) functions
where appropriate.

Location:
uspace/lib/c/generic
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

    r4f663f3e r28a5ebd  
    4646}
    4747
    48 static int asprintf_wstr_write(const wchar_t *str, size_t count, void *unused)
     48static int asprintf_wstr_write(const char32_t *str, size_t count, void *unused)
    4949{
    5050        return wstr_nlength(str, count);

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

    r4f663f3e r28a5ebd  
    140140 *
    141141 */
    142 sysarg_t chargrid_putwchar(chargrid_t *scrbuf, wchar_t ch, bool update)
     142sysarg_t chargrid_putuchar(chargrid_t *scrbuf, char32_t ch, bool update)
    143143{
    144144        assert(scrbuf->col < scrbuf->cols);
    … …  
    199199
    200200        for (sysarg_t i = 0; i < spaces; i++)
    201                 flush += chargrid_putwchar(scrbuf, ' ', true) - 1;
     201                flush += chargrid_putuchar(scrbuf, ' ', true) - 1;
    202202
    203203        return flush;
    … …  
    228228                scrbuf->row--;
    229229
    230                 chargrid_putwchar(scrbuf, ' ', false);
     230                chargrid_putuchar(scrbuf, ' ', false);
    231231                return 2;
    232232        }
    233233
    234234        scrbuf->col--;
    235         chargrid_putwchar(scrbuf, ' ', false);
     235        chargrid_putuchar(scrbuf, ' ', false);
    236236        return 1;
    237237}

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

    r4f663f3e r28a5ebd  
    109109        keycode_t key;
    110110        keymod_t mods;
    111         wchar_t c;
     111        char32_t c;
    112112        errno_t rc;
    113113

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

    r4f663f3e r28a5ebd  
    4848#include <adt/list.h>
    4949#include <wchar.h>
     50#include <uchar.h>
    5051#include "../private/io.h"
    5152#include "../private/stdio.h"
    … …  
    749750}
    750751
     752wint_t fputuc(char32_t wc, FILE *stream)
     753{
     754        char buf[STR_BOUNDS(1)];
     755        size_t sz = 0;
     756
     757        if (chr_encode(wc, buf, &sz, STR_BOUNDS(1)) != EOK) {
     758                errno = EILSEQ;
     759                return WEOF;
     760        }
     761
     762        size_t wr = fwrite(buf, 1, sz, stream);
     763        if (wr < sz)
     764                return WEOF;
     765
     766        return wc;
     767}
     768
    751769wint_t putwchar(wchar_t wc)
    752770{
    753771        return fputwc(wc, stdout);
     772}
     773
     774wint_t putuchar(char32_t wc)
     775{
     776        return fputuc(wc, stdout);
    754777}
    755778

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

    r4f663f3e r28a5ebd  
    140140}
    141141
    142 static int kio_vprintf_wstr_write(const wchar_t *str, size_t size, void *data)
     142static int kio_vprintf_wstr_write(const char32_t *str, size_t size, void *data)
    143143{
    144144        size_t offset = 0;
    … …  
    154154
    155155                chars++;
    156                 offset += sizeof(wchar_t);
     156                offset += sizeof(char32_t);
    157157        }
    158158

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

    r4f663f3e r28a5ebd  
    4747#include <assert.h>
    4848#include <macros.h>
    49 #include <wchar.h>
     49#include <uchar.h>
    5050
    5151/** show prefixes 0x or 0 */
    … …  
    187187 *
    188188 */
    189 static int printf_wputnchars(const wchar_t *buf, size_t size,
     189static int printf_wputnchars(const char32_t *buf, size_t size,
    190190    printf_spec_t *ps)
    191191{
    … …  
    233233 *
    234234 */
    235 static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
     235static int printf_putuchar(const char32_t ch, printf_spec_t *ps)
    236236{
    237237        if (!chr_check(ch))
    238238                return ps->str_write((void *) &invalch, 1, ps->data);
    239239
    240         return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
     240        return ps->wstr_write(&ch, sizeof(char32_t), ps->data);
    241241}
    242242
    … …  
    288288 *
    289289 */
    290 static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
     290static int print_wchar(const char32_t ch, int width, uint32_t flags, printf_spec_t *ps)
    291291{
    292292        size_t counter = 0;
    … …  
    302302        }
    303303
    304         if (printf_putwchar(ch, ps) > 0)
     304        if (printf_putuchar(ch, ps) > 0)
    305305                counter++;
    306306
    … …  
    375375 * @return Number of wide characters printed, negative value on failure.
    376376 */
    377 static int print_wstr(wchar_t *str, int width, unsigned int precision,
     377static int print_wstr(char32_t *str, int width, unsigned int precision,
    378378    uint32_t flags, printf_spec_t *ps)
    379379{
    … …  
    12761276 *  - "l"  Signed or unsigned long int.@n
    12771277 *         If conversion is "c", the character is wint_t (wide character).@n
    1278  *         If conversion is "s", the string is wchar_t * (wide string).@n
     1278 *         If conversion is "s", the string is char32_t * (wide string).@n
    12791279 *  - "ll" Signed or unsigned long long int.@n
    12801280 *  - "z"  Signed or unsigned ssize_t or site_t.@n
    … …  
    13301330        while (true) {
    13311331                i = nxt;
    1332                 wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
     1332                char32_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    13331333
    13341334                if (uc == 0)
    … …  
    14931493
    14941494                                if (qualifier == PrintfQualifierLong)
    1495                                         retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
     1495                                        retval = print_wstr(va_arg(ap, char32_t *), width, precision, flags, ps);
    14961496                                else
    14971497                                        retval = print_str(va_arg(ap, char *), width, precision, flags, ps);

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

    r4f663f3e r28a5ebd  
    4848}
    4949
    50 static int vprintf_wstr_write(const wchar_t *str, size_t size, void *stream)
     50static int vprintf_wstr_write(const char32_t *str, size_t size, void *stream)
    5151{
    5252        size_t offset = 0;
    … …  
    5454
    5555        while (offset < size) {
    56                 if (fputwc(str[chars], (FILE *) stream) <= 0)
     56                if (fputuc(str[chars], (FILE *) stream) <= 0)
    5757                        break;
    5858
    5959                chars++;
    60                 offset += sizeof(wchar_t);
     60                offset += sizeof(char32_t);
    6161        }
    6262

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

    r4f663f3e r28a5ebd  
    8888
    8989                while (index < size) {
    90                         wchar_t uc = str_decode(str, &index, size);
     90                        char32_t uc = str_decode(str, &index, size);
    9191
    9292                        if (chr_encode(uc, data->dst, &data->len, data->size - 1) != EOK)
    … …  
    133133 *
    134134 */
    135 static int vsnprintf_wstr_write(const wchar_t *str, size_t size, vsnprintf_data_t *data)
     135static int vsnprintf_wstr_write(const char32_t *str, size_t size, vsnprintf_data_t *data)
    136136{
    137137        size_t index = 0;
    138138
    139         while (index < (size / sizeof(wchar_t))) {
     139        while (index < (size / sizeof(char32_t))) {
    140140                size_t left = data->size - data->len;
    141141
    … …  
    177177        printf_spec_t ps = {
    178178                (int (*) (const char *, size_t, void *)) vsnprintf_str_write,
    179                 (int (*) (const wchar_t *, size_t, void *)) vsnprintf_wstr_write,
     179                (int (*) (const char32_t *, size_t, void *)) vsnprintf_wstr_write,
    180180                &data
    181181        };

  • uspace/lib/c/generic/stdio/sstream.c

    r4f663f3e r28a5ebd  
    3737#include <errno.h>
    3838#include <adt/list.h>
    39 #include <wchar.h>
     39#include <uchar.h>
    4040#include "../private/stdio.h"
    4141#include "../private/sstream.h"

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

    r4f663f3e r28a5ebd  
    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 wchar_t.@n
     44 * represented as char32_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 wchar_t
    53  *                        (signed 32 bit integer), code points 0 .. 1114111
     52 *  character             UTF-32 encoded Unicode character, stored in char32_t
     53 *                        (unsigned 32 bit integer), code points 0 .. 1114111
    5454 *                        are valid
    5555 *
    … …  
    6161 *
    6262 *  wide string           UTF-32 encoded NULL-terminated Unicode string,
    63  *                        wchar_t *
     63 *                        char32_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 *, wchar_t *)
     102 *  pointer (char *, char32_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 
    128121/** Byte mask consisting of lowest @n bits (out of 8) */
    129122#define LO_MASK_8(n)  ((uint8_t) ((1 << (n)) - 1))
    … …  
    153146 *
    154147 */
    155 wchar_t str_decode(const char *str, size_t *offset, size_t size)
     148char32_t str_decode(const char *str, size_t *offset, size_t size)
    156149{
    157150        if (*offset + 1 > size)
    … …  
    190183                return U_SPECIAL;
    191184
    192         wchar_t ch = b0 & LO_MASK_8(b0_bits);
     185        char32_t ch = b0 & LO_MASK_8(b0_bits);
    193186
    194187        /* Decode continuation bytes */
    … …  
    201194
    202195                /* Shift data bits to ch */
    203                 ch = (ch << CONT_BITS) | (wchar_t) (b & LO_MASK_8(CONT_BITS));
     196                ch = (ch << CONT_BITS) | (char32_t) (b & LO_MASK_8(CONT_BITS));
    204197                cbytes--;
    205198        }
    … …  
    223216 *
    224217 */
    225 wchar_t str_decode_reverse(const char *str, size_t *offset, size_t size)
     218char32_t str_decode_reverse(const char *str, size_t *offset, size_t size)
    226219{
    227220        if (*offset == 0)
    … …  
    266259 *         code was invalid.
    267260 */
    268 errno_t chr_encode(const wchar_t ch, char *str, size_t *offset, size_t size)
     261errno_t chr_encode(const char32_t ch, char *str, size_t *offset, size_t size)
    269262{
    270263        if (*offset >= size)
    … …  
    352345 *
    353346 */
    354 size_t wstr_size(const wchar_t *str)
    355 {
    356         return (wstr_length(str) * sizeof(wchar_t));
     347size_t wstr_size(const char32_t *str)
     348{
     349        return (wstr_length(str) * sizeof(char32_t));
    357350}
    358351
    … …  
    417410 *
    418411 */
    419 size_t wstr_nsize(const wchar_t *str, size_t max_size)
    420 {
    421         return (wstr_nlength(str, max_size) * sizeof(wchar_t));
     412size_t wstr_nsize(const char32_t *str, size_t max_size)
     413{
     414        return (wstr_nlength(str, max_size) * sizeof(char32_t));
    422415}
    423416
    … …  
    435428 *
    436429 */
    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));
     430size_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));
    440433}
    441434
    … …  
    465458 *
    466459 */
    467 size_t wstr_length(const wchar_t *wstr)
     460size_t wstr_length(const char32_t *wstr)
    468461{
    469462        size_t len = 0;
    … …  
    502495 *
    503496 */
    504 size_t wstr_nlength(const wchar_t *str, size_t size)
     497size_t wstr_nlength(const char32_t *str, size_t size)
    505498{
    506499        size_t len = 0;
    507         size_t limit = ALIGN_DOWN(size, sizeof(wchar_t));
     500        size_t limit = ALIGN_DOWN(size, sizeof(char32_t));
    508501        size_t offset = 0;
    509502
    510503        while ((offset < limit) && (*str++ != 0)) {
    511504                len++;
    512                 offset += sizeof(wchar_t);
     505                offset += sizeof(char32_t);
    513506        }
    514507
    … …  
    521514 * @return      Width of character in cells.
    522515 */
    523 size_t chr_width(wchar_t ch)
     516size_t chr_width(char32_t ch)
    524517{
    525518        return 1;
    … …  
    535528        size_t width = 0;
    536529        size_t offset = 0;
    537         wchar_t ch;
     530        char32_t ch;
    538531
    539532        while ((ch = str_decode(str, &offset, STR_NO_LIMIT)) != 0)
    … …  
    548541 *
    549542 */
    550 bool ascii_check(wchar_t ch)
    551 {
    552         if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 127))
     543bool ascii_check(char32_t ch)
     544{
     545        if (ch <= 127)
    553546                return true;
    554547
    … …  
    561554 *
    562555 */
    563 bool chr_check(wchar_t ch)
    564 {
    565         if (WCHAR_SIGNED_CHECK(ch >= 0) && (ch <= 1114111))
     556bool chr_check(char32_t ch)
     557{
     558        if (ch <= 1114111)
    566559                return true;
    567560
    … …  
    589582int str_cmp(const char *s1, const char *s2)
    590583{
    591         wchar_t c1 = 0;
    592         wchar_t c2 = 0;
     584        char32_t c1 = 0;
     585        char32_t c2 = 0;
    593586
    594587        size_t off1 = 0;
    … …  
    636629int str_lcmp(const char *s1, const char *s2, size_t max_len)
    637630{
    638         wchar_t c1 = 0;
    639         wchar_t c2 = 0;
     631        char32_t c1 = 0;
     632        char32_t c2 = 0;
    640633
    641634        size_t off1 = 0;
    … …  
    688681int str_casecmp(const char *s1, const char *s2)
    689682{
    690         wchar_t c1 = 0;
    691         wchar_t c2 = 0;
     683        char32_t c1 = 0;
     684        char32_t c2 = 0;
    692685
    693686        size_t off1 = 0;
    … …  
    736729int str_lcasecmp(const char *s1, const char *s2, size_t max_len)
    737730{
    738         wchar_t c1 = 0;
    739         wchar_t c2 = 0;
     731        char32_t c1 = 0;
     732        char32_t c2 = 0;
    740733
    741734        size_t off1 = 0;
    … …  
    780773bool str_test_prefix(const char *s, const char *p)
    781774{
    782         wchar_t c1 = 0;
    783         wchar_t c2 = 0;
     775        char32_t c1 = 0;
     776        char32_t c2 = 0;
    784777
    785778        size_t off1 = 0;
    … …  
    850843        size_t dest_off = 0;
    851844
    852         wchar_t ch;
     845        char32_t ch;
    853846        while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
    854847                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    883876        size_t dest_off = 0;
    884877
    885         wchar_t ch;
     878        char32_t ch;
    886879        while ((ch = str_decode(src, &src_off, n)) != 0) {
    887880                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    987980 * @param src   Source wide string.
    988981 */
    989 void wstr_to_str(char *dest, size_t size, const wchar_t *src)
    990 {
    991         wchar_t ch;
     982void wstr_to_str(char *dest, size_t size, const char32_t *src)
     983{
     984        char32_t ch;
    992985        size_t src_idx;
    993986        size_t dest_off;
    … …  
    10221015{
    10231016        size_t idx = 0, dest_off = 0;
    1024         wchar_t ch;
     1017        char32_t ch;
    10251018        errno_t rc = EOK;
    10261019
    … …  
    10661059        size_t offset = 0;
    10671060        size_t idx = 0;
    1068         wchar_t c;
     1061        char32_t c;
    10691062
    10701063        assert(dlen > 0);
    … …  
    11231116 * @return      New string.
    11241117 */
    1125 char *wstr_to_astr(const wchar_t *src)
     1118char *wstr_to_astr(const char32_t *src)
    11261119{
    11271120        char dbuf[STR_BOUNDS(1)];
    11281121        char *str;
    1129         wchar_t ch;
     1122        char32_t ch;
    11301123
    11311124        size_t src_idx;
    … …  
    11731166 * @param src   Source string.
    11741167 */
    1175 void str_to_wstr(wchar_t *dest, size_t dlen, const char *src)
     1168void str_to_wstr(char32_t *dest, size_t dlen, const char *src)
    11761169{
    11771170        size_t offset;
    11781171        size_t di;
    1179         wchar_t c;
     1172        char32_t c;
    11801173
    11811174        assert(dlen > 0);
    … …  
    12021195 * @param src   Source string.
    12031196 */
    1204 wchar_t *str_to_awstr(const char *str)
     1197char32_t *str_to_awstr(const char *str)
    12051198{
    12061199        size_t len = str_length(str);
    12071200
    1208         wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
     1201        char32_t *wstr = calloc(len + 1, sizeof(char32_t));
    12091202        if (wstr == NULL)
    12101203                return NULL;
    … …  
    12211214 * @return Pointer to character in @a str or NULL if not found.
    12221215 */
    1223 char *str_chr(const char *str, wchar_t ch)
    1224 {
    1225         wchar_t acc;
     1216char *str_chr(const char *str, char32_t ch)
     1217{
     1218        char32_t acc;
    12261219        size_t off = 0;
    12271220        size_t last = 0;
    … …  
    12631256 * @param ch  Character to remove.
    12641257 */
    1265 void str_rtrim(char *str, wchar_t ch)
     1258void str_rtrim(char *str, char32_t ch)
    12661259{
    12671260        size_t off = 0;
    12681261        size_t pos = 0;
    1269         wchar_t c;
     1262        char32_t c;
    12701263        bool update_last_chunk = true;
    12711264        char *last_chunk = NULL;
    … …  
    12911284 * @param ch  Character to remove.
    12921285 */
    1293 void str_ltrim(char *str, wchar_t ch)
    1294 {
    1295         wchar_t acc;
     1286void str_ltrim(char *str, char32_t ch)
     1287{
     1288        char32_t acc;
    12961289        size_t off = 0;
    12971290        size_t pos = 0;
    … …  
    13191312 * @return Pointer to character in @a str or NULL if not found.
    13201313 */
    1321 char *str_rchr(const char *str, wchar_t ch)
    1322 {
    1323         wchar_t acc;
     1314char *str_rchr(const char *str, char32_t ch)
     1315{
     1316        char32_t acc;
    13241317        size_t off = 0;
    13251318        size_t last = 0;
    … …  
    13491342 *
    13501343 */
    1351 bool wstr_linsert(wchar_t *str, wchar_t ch, size_t pos, size_t max_pos)
     1344bool wstr_linsert(char32_t *str, char32_t ch, size_t pos, size_t max_pos)
    13521345{
    13531346        size_t len = wstr_length(str);
    … …  
    13771370 *
    13781371 */
    1379 bool wstr_remove(wchar_t *str, size_t pos)
     1372bool wstr_remove(char32_t *str, size_t pos)
    13801373{
    13811374        size_t len = wstr_length(str);
    … …  
    14741467        size_t cur;
    14751468        size_t tmp;
    1476         wchar_t ch;
     1469        char32_t ch;
    14771470
    14781471        /* Skip over leading delimiters. */
Note: See TracChangeset for help on using the changeset viewer.