Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r1c9bf292 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;
    … …  
    801794
    802795        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 */
     808const 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;
    803822}
    804823
    … …  
    824843        size_t dest_off = 0;
    825844
    826         wchar_t ch;
     845        char32_t ch;
    827846        while ((ch = str_decode(src, &src_off, STR_NO_LIMIT)) != 0) {
    828847                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    857876        size_t dest_off = 0;
    858877
    859         wchar_t ch;
     878        char32_t ch;
    860879        while ((ch = str_decode(src, &src_off, n)) != 0) {
    861880                if (chr_encode(ch, dest, &dest_off, size - 1) != EOK)
    … …  
    961980 * @param src   Source wide string.
    962981 */
    963 void wstr_to_str(char *dest, size_t size, const wchar_t *src)
    964 {
    965         wchar_t ch;
     982void wstr_to_str(char *dest, size_t size, const char32_t *src)
     983{
     984        char32_t ch;
    966985        size_t src_idx;
    967986        size_t dest_off;
    … …  
    9961015{
    9971016        size_t idx = 0, dest_off = 0;
    998         wchar_t ch;
     1017        char32_t ch;
    9991018        errno_t rc = EOK;
    10001019
    … …  
    10401059        size_t offset = 0;
    10411060        size_t idx = 0;
    1042         wchar_t c;
     1061        char32_t c;
    10431062
    10441063        assert(dlen > 0);
    … …  
    10971116 * @return      New string.
    10981117 */
    1099 char *wstr_to_astr(const wchar_t *src)
     1118char *wstr_to_astr(const char32_t *src)
    11001119{
    11011120        char dbuf[STR_BOUNDS(1)];
    11021121        char *str;
    1103         wchar_t ch;
     1122        char32_t ch;
    11041123
    11051124        size_t src_idx;
    … …  
    11471166 * @param src   Source string.
    11481167 */
    1149 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)
    11501169{
    11511170        size_t offset;
    11521171        size_t di;
    1153         wchar_t c;
     1172        char32_t c;
    11541173
    11551174        assert(dlen > 0);
    … …  
    11761195 * @param src   Source string.
    11771196 */
    1178 wchar_t *str_to_awstr(const char *str)
     1197char32_t *str_to_awstr(const char *str)
    11791198{
    11801199        size_t len = str_length(str);
    11811200
    1182         wchar_t *wstr = calloc(len + 1, sizeof(wchar_t));
     1201        char32_t *wstr = calloc(len + 1, sizeof(char32_t));
    11831202        if (wstr == NULL)
    11841203                return NULL;
    … …  
    11951214 * @return Pointer to character in @a str or NULL if not found.
    11961215 */
    1197 char *str_chr(const char *str, wchar_t ch)
    1198 {
    1199         wchar_t acc;
     1216char *str_chr(const char *str, char32_t ch)
     1217{
     1218        char32_t acc;
    12001219        size_t off = 0;
    12011220        size_t last = 0;
    … …  
    12371256 * @param ch  Character to remove.
    12381257 */
    1239 void str_rtrim(char *str, wchar_t ch)
     1258void str_rtrim(char *str, char32_t ch)
    12401259{
    12411260        size_t off = 0;
    12421261        size_t pos = 0;
    1243         wchar_t c;
     1262        char32_t c;
    12441263        bool update_last_chunk = true;
    12451264        char *last_chunk = NULL;
    … …  
    12651284 * @param ch  Character to remove.
    12661285 */
    1267 void str_ltrim(char *str, wchar_t ch)
    1268 {
    1269         wchar_t acc;
     1286void str_ltrim(char *str, char32_t ch)
     1287{
     1288        char32_t acc;
    12701289        size_t off = 0;
    12711290        size_t pos = 0;
    … …  
    12931312 * @return Pointer to character in @a str or NULL if not found.
    12941313 */
    1295 char *str_rchr(const char *str, wchar_t ch)
    1296 {
    1297         wchar_t acc;
     1314char *str_rchr(const char *str, char32_t ch)
     1315{
     1316        char32_t acc;
    12981317        size_t off = 0;
    12991318        size_t last = 0;
    … …  
    13231342 *
    13241343 */
    1325 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)
    13261345{
    13271346        size_t len = wstr_length(str);
    … …  
    13511370 *
    13521371 */
    1353 bool wstr_remove(wchar_t *str, size_t pos)
     1372bool wstr_remove(char32_t *str, size_t pos)
    13541373{
    13551374        size_t len = wstr_length(str);
    … …  
    14481467        size_t cur;
    14491468        size_t tmp;
    1450         wchar_t ch;
     1469        char32_t ch;
    14511470
    14521471        /* Skip over leading delimiters. */
Note: See TracChangeset for help on using the changeset viewer.