utf-16.cpp@ 1071

Last change on this file since 1071 was 1, checked in by vboxsync, 55 years ago
import
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 16.6 KB

Line
1	/* $Id: utf-16.cpp 1 1970-01-01 00:00:00Z vboxsync $ */
2	/** @file
3	* InnoTek Portable Runtime - UTF-16
4	*/
5
6	/*
7	* Copyright (C) 2006 InnoTek Systemberatung GmbH
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License as published by the Free Software Foundation,
13	* in version 2 as it comes in the "COPYING" file of the VirtualBox OSE
14	* distribution. VirtualBox OSE is distributed in the hope that it will
15	* be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* If you received this file as part of a commercial VirtualBox
18	* distribution, then only the terms of your commercial VirtualBox
19	* license agreement apply instead of the previous paragraph.
20	*/
21
22
23	/*******************************************************************************
24	* Header Files *
25	*******************************************************************************/
26	#include <iprt/string.h>
27	#include <iprt/uni.h>
28	#include <iprt/alloc.h>
29	#include <iprt/assert.h>
30	#include <iprt/err.h>
31	#include "internal/string.h"
32
33
34
35	RTDECL(void) RTUtf16Free(PRTUTF16 pwszString)
36	{
37	if (pwszString)
38	RTMemTmpFree(pwszString);
39	}
40
41
42	RTDECL(PRTUTF16) RTUtf16Dup(PCRTUTF16 pwszString)
43	{
44	Assert(pwszString);
45	size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
46	PRTUTF16 pwsz = (PRTUTF16)RTMemAlloc(cb);
47	if (pwsz)
48	memcpy(pwsz, pwszString, cb);
49	return pwsz;
50	}
51
52
53	RTDECL(int) RTUtf16DupEx(PRTUTF16 *ppwszString, PCRTUTF16 pwszString, size_t cwcExtra)
54	{
55	Assert(pwszString);
56	size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
57	PRTUTF16 pwsz = (PRTUTF16)RTMemAlloc(cb + cwcExtra * sizeof(RTUTF16));
58	if (pwsz)
59	{
60	memcpy(pwsz, pwszString, cb);
61	*ppwszString = pwsz;
62	return VINF_SUCCESS;
63	}
64	return VERR_NO_MEMORY;
65	}
66
67
68	RTDECL(size_t) RTUtf16Len(PCRTUTF16 pwszString)
69	{
70	if (!pwszString)
71	return 0;
72
73	PCRTUTF16 pwsz = pwszString;
74	while (*pwsz)
75	pwsz++;
76	return pwsz - pwszString;
77	}
78
79
80	RTDECL(int) RTUtf16Cmp(register PCRTUTF16 pwsz1, register PCRTUTF16 pwsz2)
81	{
82	if (pwsz1 == pwsz2)
83	return 0;
84	if (!pwsz1)
85	return -1;
86	if (!pwsz2)
87	return 1;
88
89	for (;;)
90	{
91	register RTUTF16 wcs = *pwsz1;
92	register int iDiff = wcs - *pwsz2;
93	if (iDiff \|\| !wcs)
94	return iDiff;
95	pwsz1++;
96	pwsz2++;
97	}
98	}
99
100
101	RTDECL(int) RTUtf16ICmp(register PCRTUTF16 pwsz1, register PCRTUTF16 pwsz2)
102	{
103	if (pwsz1 == pwsz2)
104	return 0;
105	if (!pwsz1)
106	return -1;
107	if (!pwsz2)
108	return 1;
109
110	PCRTUTF16 pwsz1Start = pwsz1; /* keep it around in case we have to backtrack on a surrogate pair */
111	for (;;)
112	{
113	register RTUTF16 wc1 = *pwsz1;
114	register RTUTF16 wc2 = *pwsz2;
115	register int iDiff = wc1 - wc2;
116	if (iDiff)
117	{
118	/* unless they are both surrogate pairs, there is no chance they'll be identical. */
119	if ( wc1 < 0xd800
120	\|\| wc2 < 0xd800
121	\|\| wc1 > 0xdfff
122	\|\| wc2 > 0xdfff)
123	{
124	/* simple UCS-2 char */
125	iDiff = RTUniCpToUpper(wc1) - RTUniCpToUpper(wc2);
126	if (iDiff)
127	iDiff = RTUniCpToLower(wc1) - RTUniCpToLower(wc2);
128	}
129	else
130	{
131	/* a damned pair */
132	RTUNICP uc1;
133	RTUNICP uc2;
134	if (wc1 >= 0xdc00)
135	{
136	if (pwsz1Start == pwsz1)
137	return iDiff;
138	uc1 = pwsz1[-1];
139	if (uc1 < 0xd800 \|\| uc1 >= 0xdc00)
140	return iDiff;
141	uc1 = 0x10000 + (((uc1 & 0x3ff) << 10) \| (wc1 & 0x3ff));
142	uc2 = 0x10000 + (((pwsz2[-1] & 0x3ff) << 10) \| (wc2 & 0x3ff));
143	}
144	else
145	{
146	uc1 = *++pwsz1;
147	if (uc1 < 0xdc00 \|\| uc1 >= 0xe000)
148	return iDiff;
149	uc1 = 0x10000 + (((wc1 & 0x3ff) << 10) \| (uc1 & 0x3ff));
150	uc2 = 0x10000 + (((wc2 & 0x3ff) << 10) \| (*++pwsz2 & 0x3ff));
151	}
152	iDiff = RTUniCpToUpper(uc1) - RTUniCpToUpper(uc2);
153	if (iDiff)
154	iDiff = RTUniCpToLower(uc1) - RTUniCpToLower(uc2); /* serious paranoia! */
155	}
156	if (iDiff)
157	return iDiff;
158	}
159	if (!wc1)
160	return 0;
161	pwsz1++;
162	pwsz2++;
163	}
164	}
165
166
167	RTDECL(PRTUTF16) RTUtf16ToLower(PRTUTF16 pwsz)
168	{
169	PRTUTF16 pwc = pwsz;
170	for (;;)
171	{
172	RTUTF16 wc = *pwc;
173	if (!wc)
174	break;
175	if (wc < 0xd800 \|\| wc >= 0xdc00)
176	{
177	RTUNICP ucFolded = RTUniCpToLower(wc);
178	if (ucFolded < 0x10000)
179	*pwc++ = RTUniCpToLower(wc);
180	}
181	else
182	{
183	/* surrogate */
184	RTUTF16 wc2 = pwc[1];
185	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
186	{
187	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
188	RTUNICP ucFolded = RTUniCpToLower(uc);
189	if (uc != ucFolded && ucFolded >= 0x10000) /* we don't support shrinking the string */
190	{
191	uc -= 0x10000;
192	*pwc++ = 0xd800 \| (uc >> 10);
193	*pwc++ = 0xdc00 \| (uc & 0x3ff);
194	}
195	}
196	else /* invalid encoding. */
197	pwc++;
198	}
199	}
200	return pwsz;
201	}
202
203
204	RTDECL(PRTUTF16) RTUtf16ToUpper(PRTUTF16 pwsz)
205	{
206	PRTUTF16 pwc = pwsz;
207	for (;;)
208	{
209	RTUTF16 wc = *pwc;
210	if (!wc)
211	break;
212	if (wc < 0xd800 \|\| wc >= 0xdc00)
213	*pwc++ = RTUniCpToUpper(wc);
214	else
215	{
216	/* surrogate */
217	RTUTF16 wc2 = pwc[1];
218	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
219	{
220	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
221	RTUNICP ucFolded = RTUniCpToUpper(uc);
222	if (uc != ucFolded && ucFolded >= 0x10000) /* we don't support shrinking the string */
223	{
224	uc -= 0x10000;
225	*pwc++ = 0xd800 \| (uc >> 10);
226	*pwc++ = 0xdc00 \| (uc & 0x3ff);
227	}
228	}
229	else /* invalid encoding. */
230	pwc++;
231	}
232	}
233	return pwsz;
234	}
235
236
237	/**
238	* Validate the UTF-16 encoding and calculates the length of an UTF-8 encoding.
239	*
240	* @returns iprt status code.
241	* @param pwsz The UTF-16 string.
242	* @param cwc The max length of the UTF-16 string to consider.
243	* @param pcch Where to store the length (excluding '\\0') of the UTF-8 string. (cch == cb, btw)
244	*/
245	static int rtUtf16CalcUtf8Length(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
246	{
247	int rc = VINF_SUCCESS;
248	size_t cch = 0;
249	while (cwc > 0)
250	{
251	RTUTF16 wc = *pwsz++; cwc--;
252	if (!wc)
253	break;
254	else if (wc < 0xd800 \|\| wc > 0xdfff)
255	{
256	if (wc < 0x80)
257	cch++;
258	else if (wc < 0x800)
259	cch += 2;
260	else if (wc < 0xfffe)
261	cch += 3;
262	else
263	{
264	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
265	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
266	break;
267	}
268	}
269	else
270	{
271	if (wc >= 0xdc00)
272	{
273	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
274	rc = VERR_INVALID_UTF16_ENCODING;
275	break;
276	}
277	if (cwc <= 0)
278	{
279	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
280	rc = VERR_INVALID_UTF16_ENCODING;
281	break;
282	}
283	wc = *pwsz++; cwc--;
284	if (wc < 0xdc00 \|\| wc > 0xdfff)
285	{
286	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
287	rc = VERR_INVALID_UTF16_ENCODING;
288	break;
289	}
290	cch += 4;
291	}
292	}
293
294
295	/* done */
296	*pcch = cch;
297	return rc;
298	}
299
300
301	/**
302	* Recodes an valid UTF-16 string as UTF-8.
303	*
304	* @returns iprt status code.
305	* @param pwsz The UTF-16 string.
306	* @param cwc The number of RTUTF16 characters to process from pwsz. The recoding
307	* will stop when cwc or '\\0' is reached.
308	* @param psz Where to store the UTF-8 string.
309	* @param cch The size of the UTF-8 buffer, excluding the terminator.
310	* @param pcch Where to store the number of octets actually encoded.
311	*/
312	static int rtUtf16RecodeAsUtf8(PCRTUTF16 pwsz, size_t cwc, char psz, size_t cch, size_t pcch)
313	{
314	unsigned char pwch = (unsigned char )psz;
315	int rc = VINF_SUCCESS;
316	while (cwc > 0)
317	{
318	RTUTF16 wc = *pwsz++; cwc--;
319	if (!wc)
320	break;
321	else if (wc < 0xd800 \|\| wc > 0xdfff)
322	{
323	if (wc < 0x80)
324	{
325	if (cch < 1)
326	{
327	RTStrAssertMsgFailed(("Buffer overflow! 1\n"));
328	rc = VERR_BUFFER_OVERFLOW;
329	break;
330	}
331	cch--;
332	*pwch++ = (unsigned char)wc;
333	}
334	else if (wc < 0x800)
335	{
336	if (cch < 2)
337	{
338	RTStrAssertMsgFailed(("Buffer overflow! 2\n"));
339	rc = VERR_BUFFER_OVERFLOW;
340	break;
341	}
342	cch -= 2;
343	*pwch++ = 0xc0 \| (wc >> 6);
344	*pwch++ = 0x80 \| (wc & 0x3f);
345	}
346	else if (wc < 0xfffe)
347	{
348	if (cch < 3)
349	{
350	RTStrAssertMsgFailed(("Buffer overflow! 3\n"));
351	rc = VERR_BUFFER_OVERFLOW;
352	break;
353	}
354	cch -= 3;
355	*pwch++ = 0xe0 \| (wc >> 12);
356	*pwch++ = 0x80 \| ((wc >> 6) & 0x3f);
357	*pwch++ = 0x80 \| (wc & 0x3f);
358	}
359	else
360	{
361	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
362	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
363	break;
364	}
365	}
366	else
367	{
368	if (wc >= 0xdc00)
369	{
370	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
371	rc = VERR_INVALID_UTF16_ENCODING;
372	break;
373	}
374	if (cwc <= 0)
375	{
376	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
377	rc = VERR_INVALID_UTF16_ENCODING;
378	break;
379	}
380	RTUTF16 wc2 = *pwsz++; cwc--;
381	if (wc2 < 0xdc00 \|\| wc2 > 0xdfff)
382	{
383	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
384	rc = VERR_INVALID_UTF16_ENCODING;
385	break;
386	}
387	uint32_t CodePoint = 0x10000
388	+ ( ((wc & 0x3ff) << 10)
389	\| (wc2 & 0x3ff));
390	if (cch < 4)
391	{
392	RTStrAssertMsgFailed(("Buffer overflow! 4\n"));
393	rc = VERR_BUFFER_OVERFLOW;
394	break;
395	}
396	cch -= 4;
397	*pwch++ = 0xf0 \| (CodePoint >> 18);
398	*pwch++ = 0x80 \| ((CodePoint >> 12) & 0x3f);
399	*pwch++ = 0x80 \| ((CodePoint >> 6) & 0x3f);
400	*pwch++ = 0x80 \| (CodePoint & 0x3f);
401	}
402	}
403
404	/* done */
405	*pwch = '\0';
406	pcch = (char )pwch - psz;
407	return rc;
408	}
409
410
411
412	RTDECL(int) RTUtf16ToUtf8(PCRTUTF16 pwszString, char **ppszString)
413	{
414	/*
415	* Validate input.
416	*/
417	Assert(VALID_PTR(ppszString));
418	Assert(VALID_PTR(pwszString));
419	*ppszString = NULL;
420
421	/*
422	* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
423	*/
424	size_t cch;
425	int rc = rtUtf16CalcUtf8Length(pwszString, RTSTR_MAX, &cch);
426	if (RT_SUCCESS(rc))
427	{
428	/*
429	* Allocate buffer and recode it.
430	*/
431	char pszResult = (char )RTMemAlloc(cch + 1);
432	if (pszResult)
433	{
434	rc = rtUtf16RecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cch, &cch);
435	if (RT_SUCCESS(rc))
436	{
437	*ppszString = pszResult;
438	return rc;
439	}
440
441	RTMemFree(pszResult);
442	}
443	else
444	rc = VERR_NO_STR_MEMORY;
445	}
446	return rc;
447	}
448
449
450	RTDECL(int) RTUtf16ToUtf8Ex(PCRTUTF16 pwszString, size_t cwcString, char *ppsz, size_t cch, size_t pcch)
451	{
452	/*
453	* Validate input.
454	*/
455	Assert(VALID_PTR(pwszString));
456	Assert(VALID_PTR(ppsz));
457	Assert(!pcch \|\| VALID_PTR(pcch));
458
459	/*
460	* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
461	*/
462	size_t cchResult;
463	int rc = rtUtf16CalcUtf8Length(pwszString, RTSTR_MAX, &cchResult);
464	if (RT_SUCCESS(rc))
465	{
466	if (pcch)
467	*pcch = cchResult;
468
469	/*
470	* Check buffer size / Allocate buffer and recode it.
471	*/
472	bool fShouldFree;
473	char *pszResult;
474	if (cch > 0 && *ppsz)
475	{
476	fShouldFree = false;
477	if (cch <= cchResult)
478	return VERR_BUFFER_OVERFLOW;
479	cchResult = cch;
480	pszResult = *ppsz;
481	}
482	else
483	{
484	*ppsz = NULL;
485	fShouldFree = true;
486	cchResult = RT_MAX(cch, cchResult + 1);
487	pszResult = (char *)RTMemAlloc(cchResult);
488	}
489	if (pszResult)
490	{
491	rc = rtUtf16RecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cchResult, &cchResult);
492	if (RT_SUCCESS(rc))
493	{
494	*ppsz = pszResult;
495	return rc;
496	}
497
498	if (fShouldFree)
499	RTMemFree(pszResult);
500	}
501	else
502	rc = VERR_NO_STR_MEMORY;
503	}
504	return rc;
505	}
506
507
508	RTDECL(RTUNICP) RTUtf16GetCpInternal(PCRTUTF16 pwsz)
509	{
510	const RTUTF16 wc = *pwsz;
511
512	/* simple */
513	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
514	return wc;
515	if (wc < 0xfffe)
516	{
517	/* surrogate pair */
518	if (wc < 0xdc00)
519	{
520	const RTUTF16 wc2 = pwsz[1];
521	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
522	{
523	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
524	return uc;
525	}
526
527	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
528	}
529	else
530	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
531	}
532	else
533	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
534	return RTUNICP_INVALID;
535	}
536
537
538	RTDECL(int) RTUtf16GetCpExInternal(PCRTUTF16 *ppwsz, PRTUNICP pCp)
539	{
540	const RTUTF16 wc = **ppwsz;
541
542	/* simple */
543	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
544	{
545	(*ppwsz)++;
546	*pCp = wc;
547	return VINF_SUCCESS;
548	}
549
550	int rc;
551	if (wc < 0xfffe)
552	{
553	/* surrogate pair */
554	if (wc < 0xdc00)
555	{
556	const RTUTF16 wc2 = (*ppwsz)[1];
557	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
558	{
559	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
560	*pCp = uc;
561	(*ppwsz) += 2;
562	return VINF_SUCCESS;
563	}
564
565	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
566	}
567	else
568	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
569	rc = VERR_INVALID_UTF16_ENCODING;
570	}
571	else
572	{
573	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
574	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
575	}
576	*pCp = RTUNICP_INVALID;
577	(*ppwsz)++;
578	return rc;
579	}
580
581
582	RTDECL(PRTUTF16) RTUtf16PutCpInternal(PRTUTF16 pwsz, RTUNICP CodePoint)
583	{
584	/* simple */
585	if ( CodePoint < 0xd800
586	\|\| ( CodePoint > 0xdfff
587	&& CodePoint < 0xfffe))
588	{
589	*pwsz++ = (RTUTF16)CodePoint;
590	return pwsz;
591	}
592
593	/* surrogate pair */
594	if (CodePoint >= 0x10000 && CodePoint <= 0x0010ffff)
595	{
596	CodePoint -= 0x10000;
597	*pwsz++ = 0xd800 \| (CodePoint >> 10);
598	*pwsz++ = 0xdc00 \| (CodePoint & 0x3ff);
599	return pwsz;
600	}
601
602	/* invalid code point. */
603	RTStrAssertMsgFailed(("Invalid codepoint %#x\n", CodePoint));
604	*pwsz++ = 0x7f;
605	return pwsz;
606	}
607
608

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/utf-16.cpp@ 1071

Download in other formats: