lib/ucs2_string.c

   1 #include <linux/ucs2_string.h>
   2 #include <linux/module.h>
   3
   4 /* Return the number of unicode characters in data */
   5 unsigned long
   6 ucs2_strnlen(const ucs2_char_t *s, size_t maxlength)
   7 {
   8         unsigned long length = 0;
   9
  10         while (*s++ != 0 && length < maxlength)
  11                 length++;
  12         return length;
  13 }
  14 EXPORT_SYMBOL(ucs2_strnlen);
  15
  16 unsigned long
  17 ucs2_strlen(const ucs2_char_t *s)
  18 {
  19         return ucs2_strnlen(s, ~0UL);
  20 }
  21 EXPORT_SYMBOL(ucs2_strlen);
  22
  23 /*
  24  * Return the number of bytes is the length of this string
  25  * Note: this is NOT the same as the number of unicode characters
  26  */
  27 unsigned long
  28 ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength)
  29 {
  30         return ucs2_strnlen(data, maxlength/sizeof(ucs2_char_t)) * sizeof(ucs2_char_t);
  31 }
  32 EXPORT_SYMBOL(ucs2_strsize);
  33
  34 int
  35 ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len)
  36 {
  37         while (1) {
  38                 if (len == 0)
  39                         return 0;
  40                 if (*a < *b)
  41                         return -1;
  42                 if (*a > *b)
  43                         return 1;
  44                 if (*a == 0) /* implies *b == 0 */
  45                         return 0;
  46                 a++;
  47                 b++;
  48                 len--;
  49         }
  50 }
  51 EXPORT_SYMBOL(ucs2_strncmp);
  52
  53 unsigned long
  54 ucs2_utf8size(const ucs2_char_t *src)
  55 {
  56         unsigned long i;
  57         unsigned long j = 0;
  58
  59         for (i = 0; src[i]; i++) {
  60                 u16 c = src[i];
  61
  62                 if (c >= 0x800)
  63                         j += 3;
  64                 else if (c >= 0x80)
  65                         j += 2;
  66                 else
  67                         j += 1;
  68         }
  69
  70         return j;
  71 }
  72 EXPORT_SYMBOL(ucs2_utf8size);
  73
  74 /*
  75  * copy at most maxlength bytes of whole utf8 characters to dest from the
  76  * ucs2 string src.
  77  *
  78  * The return value is the number of characters copied, not including the
  79  * final NUL character.
  80  */
  81 unsigned long
  82 ucs2_as_utf8(u8 *dest, const ucs2_char_t *src, unsigned long maxlength)
  83 {
  84         unsigned int i;
  85         unsigned long j = 0;
  86         unsigned long limit = ucs2_strnlen(src, maxlength);
  87
  88         for (i = 0; maxlength && i < limit; i++) {
  89                 u16 c = src[i];
  90
  91                 if (c >= 0x800) {
  92                         if (maxlength < 3)
  93                                 break;
  94                         maxlength -= 3;
  95                         dest[j++] = 0xe0 | (c & 0xf000) >> 12;
  96                         dest[j++] = 0x80 | (c & 0x0fc0) >> 6;
  97                         dest[j++] = 0x80 | (c & 0x003f);
  98                 } else if (c >= 0x80) {
  99                         if (maxlength < 2)
 100                                 break;
 101                         maxlength -= 2;
 102                         dest[j++] = 0xc0 | (c & 0x7c0) >> 6;
 103                         dest[j++] = 0x80 | (c & 0x03f);
 104                 } else {
 105                         maxlength -= 1;
 106                         dest[j++] = c & 0x7f;
 107                 }
 108         }
 109         if (maxlength)
 110                 dest[j] = '\0';
 111         return j;
 112 }
 113 EXPORT_SYMBOL(ucs2_as_utf8);