Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/lib/c/generic/str.c

    rabb7491c rdcb74c0a  
    22 * Copyright (c) 2005 Martin Decky
    33 * Copyright (c) 2008 Jiri Svoboda
    4  * Copyright (c) 2011 Martin Sucha
    5  * Copyright (c) 2011 Oleg Romanenko
    64 * All rights reserved.
    75 *
     
    641639}
    642640
    643 /** Convert UTF16 string to string.
    644  *
    645  * Convert utf16 string @a src to string. The output is written to the buffer
    646  * specified by @a dest and @a size. @a size must be non-zero and the string
    647  * written will always be well-formed. Surrogate pairs also supported.
    648  *
    649  * @param dest  Destination buffer.
    650  * @param size  Size of the destination buffer.
    651  * @param src   Source utf16 string.
    652  *
    653  * @return EOK, if success, negative otherwise.
    654  */
    655 int utf16_to_str(char *dest, size_t size, const uint16_t *src)
    656 {
    657         size_t idx = 0, dest_off = 0;
    658         wchar_t ch;
    659         int rc = EOK;
    660 
    661         /* There must be space for a null terminator in the buffer. */
    662         assert(size > 0);
    663 
    664         while (src[idx]) {
    665                 if ((src[idx] & 0xfc00) == 0xd800) {
    666                         if (src[idx + 1] && (src[idx + 1] & 0xfc00) == 0xdc00) {
    667                                 ch = 0x10000;
    668                                 ch += (src[idx] & 0x03FF) << 10;
    669                                 ch += (src[idx + 1] & 0x03FF);
    670                                 idx += 2;
    671                         }
    672                         else
    673                                 break;
    674                 } else {
    675                         ch = src[idx];
    676                         idx++;
    677                 }
    678                 rc = chr_encode(ch, dest, &dest_off, size - 1);
    679                 if (rc != EOK)
    680                         break;
    681         }
    682         dest[dest_off] = '\0';
    683         return rc;
    684 }
    685 
    686 int str_to_utf16(uint16_t *dest, size_t size, const char *src)
    687 {
    688         int rc = EOK;
    689         size_t offset = 0;
    690         size_t idx = 0;
    691         wchar_t c;
    692 
    693         assert(size > 0);
    694        
    695         while ((c = str_decode(src, &offset, STR_NO_LIMIT)) != 0) {
    696                 if (c > 0x10000) {
    697                         if (idx + 2 >= size - 1) {
    698                                 rc = EOVERFLOW;
    699                                 break;
    700                         }
    701                         c = (c - 0x10000);
    702                         dest[idx] = 0xD800 | (c >> 10);
    703                         dest[idx + 1] = 0xDC00 | (c & 0x3FF);
    704                         idx++;
    705                 } else {
    706                          dest[idx] = c;
    707                 }
    708 
    709                 idx++;
    710                 if (idx >= size - 1) {
    711                         rc = EOVERFLOW;
    712                         break;
    713                 }
    714         }
    715 
    716         dest[idx] = '\0';
    717         return rc;
    718 }
    719 
    720 
    721641/** Convert wide string to new string.
    722642 *
     
    798718
    799719        dest[dlen - 1] = '\0';
    800 }
    801 
    802 /** Convert string to wide string.
    803  *
    804  * Convert string @a src to wide string. A new wide NULL-terminated
    805  * string will be allocated on the heap.
    806  *
    807  * @param src   Source string.
    808  */
    809 wchar_t *str_to_awstr(const char *str)
    810 {
    811         size_t len = str_length(str);
    812        
    813         wchar_t *wstr = calloc(len+1, sizeof(wchar_t));
    814         if (wstr == NULL)
    815                 return NULL;
    816        
    817         str_to_wstr(wstr, len + 1, str);
    818         return wstr;
    819720}
    820721
     
    11151016        return dest;
    11161017}
     1018
    11171019
    11181020/** Convert initial part of string to unsigned long according to given base.
Note: See TracChangeset for help on using the changeset viewer.