Branch data     Line data    Source code

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