Linux Audio

Check our new training course

Loading...
v5.14.15
  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 */
  6unsigned long
  7ucs2_strnlen(const ucs2_char_t *s, size_t maxlength)
  8{
  9        unsigned long length = 0;
 10
 11        while (*s++ != 0 && length < maxlength)
 12                length++;
 13        return length;
 14}
 15EXPORT_SYMBOL(ucs2_strnlen);
 16
 17unsigned long
 18ucs2_strlen(const ucs2_char_t *s)
 19{
 20        return ucs2_strnlen(s, ~0UL);
 21}
 22EXPORT_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 */
 28unsigned long
 29ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength)
 30{
 31        return ucs2_strnlen(data, maxlength/sizeof(ucs2_char_t)) * sizeof(ucs2_char_t);
 32}
 33EXPORT_SYMBOL(ucs2_strsize);
 34
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 35int
 36ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len)
 37{
 38        while (1) {
 39                if (len == 0)
 40                        return 0;
 41                if (*a < *b)
 42                        return -1;
 43                if (*a > *b)
 44                        return 1;
 45                if (*a == 0) /* implies *b == 0 */
 46                        return 0;
 47                a++;
 48                b++;
 49                len--;
 50        }
 51}
 52EXPORT_SYMBOL(ucs2_strncmp);
 53
 54unsigned long
 55ucs2_utf8size(const ucs2_char_t *src)
 56{
 57	unsigned long i;
 58	unsigned long j = 0;
 59
 60	for (i = 0; src[i]; i++) {
 61		u16 c = src[i];
 62
 63		if (c >= 0x800)
 64			j += 3;
 65		else if (c >= 0x80)
 66			j += 2;
 67		else
 68			j += 1;
 69	}
 70
 71	return j;
 72}
 73EXPORT_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 */
 82unsigned long
 83ucs2_as_utf8(u8 *dest, const ucs2_char_t *src, unsigned long maxlength)
 84{
 85	unsigned int i;
 86	unsigned long j = 0;
 87	unsigned long limit = ucs2_strnlen(src, maxlength);
 88
 89	for (i = 0; maxlength && i < limit; i++) {
 90		u16 c = src[i];
 91
 92		if (c >= 0x800) {
 93			if (maxlength < 3)
 94				break;
 95			maxlength -= 3;
 96			dest[j++] = 0xe0 | (c & 0xf000) >> 12;
 97			dest[j++] = 0x80 | (c & 0x0fc0) >> 6;
 98			dest[j++] = 0x80 | (c & 0x003f);
 99		} else if (c >= 0x80) {
100			if (maxlength < 2)
101				break;
102			maxlength -= 2;
103			dest[j++] = 0xc0 | (c & 0x7c0) >> 6;
104			dest[j++] = 0x80 | (c & 0x03f);
105		} else {
106			maxlength -= 1;
107			dest[j++] = c & 0x7f;
108		}
109	}
110	if (maxlength)
111		dest[j] = '\0';
112	return j;
113}
114EXPORT_SYMBOL(ucs2_as_utf8);
115
116MODULE_LICENSE("GPL v2");
v6.13.7
  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 */
  6unsigned long
  7ucs2_strnlen(const ucs2_char_t *s, size_t maxlength)
  8{
  9        unsigned long length = 0;
 10
 11        while (*s++ != 0 && length < maxlength)
 12                length++;
 13        return length;
 14}
 15EXPORT_SYMBOL(ucs2_strnlen);
 16
 17unsigned long
 18ucs2_strlen(const ucs2_char_t *s)
 19{
 20        return ucs2_strnlen(s, ~0UL);
 21}
 22EXPORT_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 */
 28unsigned long
 29ucs2_strsize(const ucs2_char_t *data, unsigned long maxlength)
 30{
 31        return ucs2_strnlen(data, maxlength/sizeof(ucs2_char_t)) * sizeof(ucs2_char_t);
 32}
 33EXPORT_SYMBOL(ucs2_strsize);
 34
 35/**
 36 * ucs2_strscpy() - Copy a UCS2 string into a sized buffer.
 37 *
 38 * @dst: Pointer to the destination buffer where to copy the string to.
 39 * @src: Pointer to the source buffer where to copy the string from.
 40 * @count: Size of the destination buffer, in UCS2 (16-bit) characters.
 41 *
 42 * Like strscpy(), only for UCS2 strings.
 43 *
 44 * Copy the source string @src, or as much of it as fits, into the destination
 45 * buffer @dst. The behavior is undefined if the string buffers overlap. The
 46 * destination buffer @dst is always NUL-terminated, unless it's zero-sized.
 47 *
 48 * Return: The number of characters copied into @dst (excluding the trailing
 49 * %NUL terminator) or -E2BIG if @count is 0 or @src was truncated due to the
 50 * destination buffer being too small.
 51 */
 52ssize_t ucs2_strscpy(ucs2_char_t *dst, const ucs2_char_t *src, size_t count)
 53{
 54	long res;
 55
 56	/*
 57	 * Ensure that we have a valid amount of space. We need to store at
 58	 * least one NUL-character.
 59	 */
 60	if (count == 0 || WARN_ON_ONCE(count > INT_MAX / sizeof(*dst)))
 61		return -E2BIG;
 62
 63	/*
 64	 * Copy at most 'count' characters, return early if we find a
 65	 * NUL-terminator.
 66	 */
 67	for (res = 0; res < count; res++) {
 68		ucs2_char_t c;
 69
 70		c = src[res];
 71		dst[res] = c;
 72
 73		if (!c)
 74			return res;
 75	}
 76
 77	/*
 78	 * The loop above terminated without finding a NUL-terminator,
 79	 * exceeding the 'count': Enforce proper NUL-termination and return
 80	 * error.
 81	 */
 82	dst[count - 1] = 0;
 83	return -E2BIG;
 84}
 85EXPORT_SYMBOL(ucs2_strscpy);
 86
 87int
 88ucs2_strncmp(const ucs2_char_t *a, const ucs2_char_t *b, size_t len)
 89{
 90        while (1) {
 91                if (len == 0)
 92                        return 0;
 93                if (*a < *b)
 94                        return -1;
 95                if (*a > *b)
 96                        return 1;
 97                if (*a == 0) /* implies *b == 0 */
 98                        return 0;
 99                a++;
100                b++;
101                len--;
102        }
103}
104EXPORT_SYMBOL(ucs2_strncmp);
105
106unsigned long
107ucs2_utf8size(const ucs2_char_t *src)
108{
109	unsigned long i;
110	unsigned long j = 0;
111
112	for (i = 0; src[i]; i++) {
113		u16 c = src[i];
114
115		if (c >= 0x800)
116			j += 3;
117		else if (c >= 0x80)
118			j += 2;
119		else
120			j += 1;
121	}
122
123	return j;
124}
125EXPORT_SYMBOL(ucs2_utf8size);
126
127/*
128 * copy at most maxlength bytes of whole utf8 characters to dest from the
129 * ucs2 string src.
130 *
131 * The return value is the number of characters copied, not including the
132 * final NUL character.
133 */
134unsigned long
135ucs2_as_utf8(u8 *dest, const ucs2_char_t *src, unsigned long maxlength)
136{
137	unsigned int i;
138	unsigned long j = 0;
139	unsigned long limit = ucs2_strnlen(src, maxlength);
140
141	for (i = 0; maxlength && i < limit; i++) {
142		u16 c = src[i];
143
144		if (c >= 0x800) {
145			if (maxlength < 3)
146				break;
147			maxlength -= 3;
148			dest[j++] = 0xe0 | (c & 0xf000) >> 12;
149			dest[j++] = 0x80 | (c & 0x0fc0) >> 6;
150			dest[j++] = 0x80 | (c & 0x003f);
151		} else if (c >= 0x80) {
152			if (maxlength < 2)
153				break;
154			maxlength -= 2;
155			dest[j++] = 0xc0 | (c & 0x7c0) >> 6;
156			dest[j++] = 0x80 | (c & 0x03f);
157		} else {
158			maxlength -= 1;
159			dest[j++] = c & 0x7f;
160		}
161	}
162	if (maxlength)
163		dest[j] = '\0';
164	return j;
165}
166EXPORT_SYMBOL(ucs2_as_utf8);
167
168MODULE_LICENSE("GPL v2");