utf-16.cpp@ 96563

Last change on this file since 96563 was 96407, checked in by vboxsync, 2 years ago
scm copyright and license note update
Property svn:eol-style set to `native` Property svn:keywords set to `Id Revision`
File size: 36.3 KB

Line
1	/* $Id: utf-16.cpp 96407 2022-08-22 17:43:14Z vboxsync $ */
2	/** @file
3	* IPRT - UTF-16.
4	*/
5
6	/*
7	* Copyright (C) 2006-2022 Oracle and/or its affiliates.
8	*
9	* This file is part of VirtualBox base platform packages, as
10	* available from https://www.virtualbox.org.
11	*
12	* This program is free software; you can redistribute it and/or
13	* modify it under the terms of the GNU General Public License
14	* as published by the Free Software Foundation, in version 3 of the
15	* License.
16	*
17	* This program is distributed in the hope that it will be useful, but
18	* WITHOUT ANY WARRANTY; without even the implied warranty of
19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20	* General Public License for more details.
21	*
22	* You should have received a copy of the GNU General Public License
23	* along with this program; if not, see <https://www.gnu.org/licenses>.
24	*
25	* The contents of this file may alternatively be used under the terms
26	* of the Common Development and Distribution License Version 1.0
27	* (CDDL), a copy of it is provided in the "COPYING.CDDL" file included
28	* in the VirtualBox distribution, in which case the provisions of the
29	* CDDL are applicable instead of those of the GPL.
30	*
31	* You may elect to license modified versions of this file under the
32	* terms and conditions of either the GPL or the CDDL or both.
33	*
34	* SPDX-License-Identifier: GPL-3.0-only OR CDDL-1.0
35	*/
36
37
38	/*********************************************************************************************************************************
39	* Header Files *
40	*********************************************************************************************************************************/
41	#include <iprt/utf16.h>
42	#include "internal/iprt.h"
43
44	#include <iprt/uni.h>
45	#include <iprt/asm.h>
46	#include <iprt/mem.h>
47	#include <iprt/assert.h>
48	#include <iprt/err.h>
49	#include "internal/string.h"
50
51
52	/**
53	* Get get length in code points of an UTF-16 encoded string, validating the
54	* string while doing so.
55	*
56	* @returns IPRT status code.
57	* @param pwsz Pointer to the UTF-16 string.
58	* @param cwc The max length of the string in UTF-16 units. Use
59	* RTSTR_MAX if all of the string is to be examined.
60	* @param pcuc Where to store the length in unicode code points.
61	* @param pcwcActual Where to store the actual size of the UTF-16 string
62	* on success. Optional.
63	*/
64	static int rtUtf16Length(PCRTUTF16 pwsz, size_t cwc, size_t pcuc, size_t pcwcActual)
65	{
66	PCRTUTF16 pwszStart = pwsz;
67	size_t cCodePoints = 0;
68	while (cwc > 0)
69	{
70	RTUTF16 wc = *pwsz;
71	if (!wc)
72	break;
73	if (wc < 0xd800 \|\| wc > 0xdfff)
74	{
75	cCodePoints++;
76	pwsz++;
77	cwc--;
78	}
79	/* Surrogate pair: */
80	else if (wc >= 0xdc00)
81	{
82	RTStrAssertMsgFailed(("Lone UTF-16 trail surrogate: %#x (%.Rhxs)\n", wc, RT_MIN(cwc 2, 10), pwsz));
83	return VERR_INVALID_UTF16_ENCODING;
84	}
85	else if (cwc < 2)
86	{
87	RTStrAssertMsgFailed(("Lone UTF-16 lead surrogate: %#x\n", wc));
88	return VERR_INVALID_UTF16_ENCODING;
89	}
90	else
91	{
92	RTUTF16 wcTrail = pwsz[1];
93	if (wcTrail < 0xdc00 \|\| wcTrail > 0xdfff)
94	{
95	RTStrAssertMsgFailed(("Invalid UTF-16 trail surrogate: %#x (lead %#x)\n", wcTrail, wc));
96	return VERR_INVALID_UTF16_ENCODING;
97	}
98
99	cCodePoints++;
100	pwsz += 2;
101	cwc -= 2;
102	}
103	}
104
105	/* done */
106	*pcuc = cCodePoints;
107	if (pcwcActual)
108	*pcwcActual = pwsz - pwszStart;
109	return VINF_SUCCESS;
110	}
111
112
113	RTDECL(PRTUTF16) RTUtf16AllocTag(size_t cb, const char *pszTag)
114	{
115	if (cb > sizeof(RTUTF16))
116	cb = RT_ALIGN_Z(cb, sizeof(RTUTF16));
117	else
118	cb = sizeof(RTUTF16);
119	PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb, pszTag);
120	if (pwsz)
121	*pwsz = '\0';
122	return pwsz;
123	}
124	RT_EXPORT_SYMBOL(RTUtf16AllocTag);
125
126
127	RTDECL(int) RTUtf16ReallocTag(PRTUTF16 ppwsz, size_t cbNew, const char pszTag)
128	{
129	PRTUTF16 pwszOld = *ppwsz;
130	cbNew = RT_ALIGN_Z(cbNew, sizeof(RTUTF16));
131	if (!cbNew)
132	{
133	RTMemFree(pwszOld);
134	*ppwsz = NULL;
135	}
136	else if (pwszOld)
137	{
138	PRTUTF16 pwszNew = (PRTUTF16)RTMemReallocTag(pwszOld, cbNew, pszTag);
139	if (!pwszNew)
140	return VERR_NO_STR_MEMORY;
141	pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
142	*ppwsz = pwszNew;
143	}
144	else
145	{
146	PRTUTF16 pwszNew = (PRTUTF16)RTMemAllocTag(cbNew, pszTag);
147	if (!pwszNew)
148	return VERR_NO_UTF16_MEMORY;
149	pwszNew[0] = '\0';
150	pwszNew[cbNew / sizeof(RTUTF16) - 1] = '\0';
151	*ppwsz = pwszNew;
152	}
153	return VINF_SUCCESS;
154	}
155	RT_EXPORT_SYMBOL(RTUtf16ReallocTag);
156
157
158	RTDECL(void) RTUtf16Free(PRTUTF16 pwszString)
159	{
160	if (pwszString)
161	RTMemTmpFree(pwszString);
162	}
163	RT_EXPORT_SYMBOL(RTUtf16Free);
164
165
166	RTDECL(PRTUTF16) RTUtf16DupTag(PCRTUTF16 pwszString, const char *pszTag)
167	{
168	Assert(pwszString);
169	size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
170	PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb, pszTag);
171	if (pwsz)
172	memcpy(pwsz, pwszString, cb);
173	return pwsz;
174	}
175	RT_EXPORT_SYMBOL(RTUtf16DupTag);
176
177
178	RTDECL(int) RTUtf16DupExTag(PRTUTF16 ppwszString, PCRTUTF16 pwszString, size_t cwcExtra, const char pszTag)
179	{
180	Assert(pwszString);
181	size_t cb = (RTUtf16Len(pwszString) + 1) * sizeof(RTUTF16);
182	PRTUTF16 pwsz = (PRTUTF16)RTMemAllocTag(cb + cwcExtra * sizeof(RTUTF16), pszTag);
183	if (pwsz)
184	{
185	memcpy(pwsz, pwszString, cb);
186	*ppwszString = pwsz;
187	return VINF_SUCCESS;
188	}
189	return VERR_NO_MEMORY;
190	}
191	RT_EXPORT_SYMBOL(RTUtf16DupExTag);
192
193
194	RTDECL(size_t) RTUtf16Len(PCRTUTF16 pwszString)
195	{
196	if (!pwszString)
197	return 0;
198
199	PCRTUTF16 pwsz = pwszString;
200	while (*pwsz)
201	pwsz++;
202	return pwsz - pwszString;
203	}
204	RT_EXPORT_SYMBOL(RTUtf16Len);
205
206
207	RTDECL(int) RTUtf16Cmp(PCRTUTF16 pwsz1, PCRTUTF16 pwsz2)
208	{
209	if (pwsz1 == pwsz2)
210	return 0;
211	if (!pwsz1)
212	return -1;
213	if (!pwsz2)
214	return 1;
215
216	for (;;)
217	{
218	RTUTF16 wcs = *pwsz1;
219	int iDiff = wcs - *pwsz2;
220	if (iDiff \|\| !wcs)
221	return iDiff;
222	pwsz1++;
223	pwsz2++;
224	}
225	}
226	RT_EXPORT_SYMBOL(RTUtf16Cmp);
227
228
229	RTDECL(int) RTUtf16CmpUtf8(PCRTUTF16 pwsz1, const char *psz2)
230	{
231	/*
232	* NULL and empty strings are all the same.
233	*/
234	if (!pwsz1)
235	return !psz2 \|\| !*psz2 ? 0 : -1;
236	if (!psz2)
237	return !*pwsz1 ? 0 : 1;
238
239	/*
240	* Compare with a UTF-8 string by enumerating them char by char.
241	*/
242	for (;;)
243	{
244	RTUNICP uc1;
245	int rc = RTUtf16GetCpEx(&pwsz1, &uc1);
246	AssertRCReturn(rc, 1);
247
248	RTUNICP uc2;
249	rc = RTStrGetCpEx(&psz2, &uc2);
250	AssertRCReturn(rc, -1);
251	if (uc1 == uc2)
252	{
253	if (uc1)
254	continue;
255	return 0;
256	}
257	return uc1 < uc2 ? -1 : 1;
258	}
259	}
260	RT_EXPORT_SYMBOL(RTUtf16CmpUtf8);
261
262
263	RTDECL(int) RTUtf16ValidateEncoding(PCRTUTF16 pwsz)
264	{
265	return RTUtf16ValidateEncodingEx(pwsz, RTSTR_MAX, 0);
266	}
267	RT_EXPORT_SYMBOL(RTUtf16ValidateEncoding);
268
269
270	RTDECL(int) RTUtf16ValidateEncodingEx(PCRTUTF16 pwsz, size_t cwc, uint32_t fFlags)
271	{
272	AssertReturn(!(fFlags & ~(RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED \| RTSTR_VALIDATE_ENCODING_EXACT_LENGTH)),
273	VERR_INVALID_PARAMETER);
274	AssertPtr(pwsz);
275
276	/*
277	* Use rtUtf16Length for the job.
278	*/
279	size_t cwcActual = 0; /* Shut up cc1plus. */
280	size_t cCpsIgnored;
281	int rc = rtUtf16Length(pwsz, cwc, &cCpsIgnored, &cwcActual);
282	if (RT_SUCCESS(rc))
283	{
284	if (fFlags & RTSTR_VALIDATE_ENCODING_EXACT_LENGTH)
285	{
286	if (fFlags & RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED)
287	cwcActual++;
288	if (cwcActual == cwc)
289	rc = VINF_SUCCESS;
290	else if (cwcActual < cwc)
291	rc = VERR_BUFFER_UNDERFLOW;
292	else
293	rc = VERR_BUFFER_OVERFLOW;
294	}
295	else if ( (fFlags & RTSTR_VALIDATE_ENCODING_ZERO_TERMINATED)
296	&& cwcActual >= cwc)
297	rc = VERR_BUFFER_OVERFLOW;
298	}
299	return rc;
300	}
301	RT_EXPORT_SYMBOL(RTUtf16ValidateEncodingEx);
302
303
304	RTDECL(bool) RTUtf16IsValidEncoding(PCRTUTF16 pwsz)
305	{
306	int rc = RTUtf16ValidateEncodingEx(pwsz, RTSTR_MAX, 0);
307	return RT_SUCCESS(rc);
308	}
309	RT_EXPORT_SYMBOL(RTUtf16IsValidEncoding);
310
311
312	/**
313	* Helper for RTUtf16PurgeComplementSet.
314	*
315	* @returns true if @a Cp is valid, false if not.
316	* @param Cp The code point to validate.
317	* @param puszValidPairs Pair of valid code point sets.
318	* @param cValidPairs Number of pairs.
319	*/
320	DECLINLINE(bool) rtUtf16PurgeIsInSet(RTUNICP Cp, PCRTUNICP puszValidPairs, uint32_t cValidPairs)
321	{
322	while (cValidPairs-- > 0)
323	{
324	if ( Cp >= puszValidPairs[0]
325	&& Cp <= puszValidPairs[1])
326	return true;
327	puszValidPairs += 2;
328	}
329	return false;
330	}
331
332
333	RTDECL(ssize_t) RTUtf16PurgeComplementSet(PRTUTF16 pwsz, PCRTUNICP puszValidPairs, char chReplacement)
334	{
335	AssertReturn(chReplacement && (unsigned)chReplacement < 128, -1);
336
337	/*
338	* Calc valid pairs and check that we've got an even number.
339	*/
340	uint32_t cValidPairs = 0;
341	while (puszValidPairs[cValidPairs * 2])
342	{
343	AssertReturn(puszValidPairs[cValidPairs * 2 + 1], -1);
344	AssertMsg(puszValidPairs[cValidPairs * 2] <= puszValidPairs[cValidPairs * 2 + 1],
345	("%#x vs %#x\n", puszValidPairs[cValidPairs * 2], puszValidPairs[cValidPairs * 2 + 1]));
346	cValidPairs++;
347	}
348
349	/*
350	* Do the replacing.
351	*/
352	ssize_t cReplacements = 0;
353	for (;;)
354	{
355	PRTUTF16 pwszCur = pwsz;
356	RTUNICP Cp;
357	int rc = RTUtf16GetCpEx((PCRTUTF16 *)&pwsz, &Cp);
358	if (RT_SUCCESS(rc))
359	{
360	if (Cp)
361	{
362	if (!rtUtf16PurgeIsInSet(Cp, puszValidPairs, cValidPairs))
363	{
364	for (; pwszCur != pwsz; ++pwszCur)
365	*pwszCur = chReplacement;
366	++cReplacements;
367	}
368	}
369	else
370	break;
371	}
372	else
373	return -1;
374	}
375	return cReplacements;
376	}
377	RT_EXPORT_SYMBOL(RTUtf16PurgeComplementSet);
378
379
380	/**
381	* Validate the UTF-16BE encoding and calculates the length of an UTF-8
382	* encoding.
383	*
384	* @returns iprt status code.
385	* @param pwsz The UTF-16BE string.
386	* @param cwc The max length of the UTF-16BE string to consider.
387	* @param pcch Where to store the length (excluding '\\0') of the UTF-8 string. (cch == cb, btw)
388	*
389	* @note rtUtf16LittleCalcUtf8Length \| s/RT_LE2H_U16/RT_BE2H_U16/g
390	*/
391	static int rtUtf16BigCalcUtf8Length(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
392	{
393	int rc = VINF_SUCCESS;
394	size_t cch = 0;
395	while (cwc > 0)
396	{
397	RTUTF16 wc = *pwsz++; cwc--;
398	if (!wc)
399	break;
400	wc = RT_BE2H_U16(wc);
401	if (wc < 0xd800 \|\| wc > 0xdfff)
402	{
403	if (wc < 0x80)
404	cch++;
405	else if (wc < 0x800)
406	cch += 2;
407	else if (wc < 0xfffe)
408	cch += 3;
409	else
410	{
411	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
412	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
413	break;
414	}
415	}
416	else
417	{
418	if (wc >= 0xdc00)
419	{
420	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
421	rc = VERR_INVALID_UTF16_ENCODING;
422	break;
423	}
424	if (cwc <= 0)
425	{
426	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
427	rc = VERR_INVALID_UTF16_ENCODING;
428	break;
429	}
430	wc = *pwsz++; cwc--;
431	wc = RT_BE2H_U16(wc);
432	if (wc < 0xdc00 \|\| wc > 0xdfff)
433	{
434	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
435	rc = VERR_INVALID_UTF16_ENCODING;
436	break;
437	}
438	cch += 4;
439	}
440	}
441
442
443	/* done */
444	*pcch = cch;
445	return rc;
446	}
447
448
449	/**
450	* Validate the UTF-16LE encoding and calculates the length of an UTF-8
451	* encoding.
452	*
453	* @returns iprt status code.
454	* @param pwsz The UTF-16LE string.
455	* @param cwc The max length of the UTF-16LE string to consider.
456	* @param pcch Where to store the length (excluding '\\0') of the UTF-8 string. (cch == cb, btw)
457	*
458	* @note rtUtf16BigCalcUtf8Length \| s/RT_BE2H_U16/RT_LE2H_U16/g
459	*/
460	static int rtUtf16LittleCalcUtf8Length(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
461	{
462	int rc = VINF_SUCCESS;
463	size_t cch = 0;
464	while (cwc > 0)
465	{
466	RTUTF16 wc = *pwsz++; cwc--;
467	if (!wc)
468	break;
469	wc = RT_LE2H_U16(wc);
470	if (wc < 0xd800 \|\| wc > 0xdfff)
471	{
472	if (wc < 0x80)
473	cch++;
474	else if (wc < 0x800)
475	cch += 2;
476	else if (wc < 0xfffe)
477	cch += 3;
478	else
479	{
480	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
481	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
482	break;
483	}
484	}
485	else
486	{
487	if (wc >= 0xdc00)
488	{
489	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
490	rc = VERR_INVALID_UTF16_ENCODING;
491	break;
492	}
493	if (cwc <= 0)
494	{
495	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
496	rc = VERR_INVALID_UTF16_ENCODING;
497	break;
498	}
499	wc = *pwsz++; cwc--;
500	wc = RT_LE2H_U16(wc);
501	if (wc < 0xdc00 \|\| wc > 0xdfff)
502	{
503	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
504	rc = VERR_INVALID_UTF16_ENCODING;
505	break;
506	}
507	cch += 4;
508	}
509	}
510
511
512	/* done */
513	*pcch = cch;
514	return rc;
515	}
516
517
518	/**
519	* Recodes an valid UTF-16BE string as UTF-8.
520	*
521	* @returns iprt status code.
522	* @param pwsz The UTF-16BE string.
523	* @param cwc The number of RTUTF16 characters to process from pwsz. The recoding
524	* will stop when cwc or '\\0' is reached.
525	* @param psz Where to store the UTF-8 string.
526	* @param cch The size of the UTF-8 buffer, excluding the terminator.
527	* @param pcch Where to store the number of octets actually encoded.
528	*
529	* @note rtUtf16LittleRecodeAsUtf8 == s/RT_BE2H_U16/RT_LE2H_U16/g
530	*/
531	static int rtUtf16BigRecodeAsUtf8(PCRTUTF16 pwsz, size_t cwc, char psz, size_t cch, size_t pcch)
532	{
533	unsigned char pwch = (unsigned char )psz;
534	int rc = VINF_SUCCESS;
535	while (cwc > 0)
536	{
537	RTUTF16 wc = *pwsz++; cwc--;
538	if (!wc)
539	break;
540	wc = RT_BE2H_U16(wc);
541	if (wc < 0xd800 \|\| wc > 0xdfff)
542	{
543	if (wc < 0x80)
544	{
545	if (RT_UNLIKELY(cch < 1))
546	{
547	RTStrAssertMsgFailed(("Buffer overflow! 1\n"));
548	rc = VERR_BUFFER_OVERFLOW;
549	break;
550	}
551	cch--;
552	*pwch++ = (unsigned char)wc;
553	}
554	else if (wc < 0x800)
555	{
556	if (RT_UNLIKELY(cch < 2))
557	{
558	RTStrAssertMsgFailed(("Buffer overflow! 2\n"));
559	rc = VERR_BUFFER_OVERFLOW;
560	break;
561	}
562	cch -= 2;
563	*pwch++ = 0xc0 \| (wc >> 6);
564	*pwch++ = 0x80 \| (wc & 0x3f);
565	}
566	else if (wc < 0xfffe)
567	{
568	if (RT_UNLIKELY(cch < 3))
569	{
570	RTStrAssertMsgFailed(("Buffer overflow! 3\n"));
571	rc = VERR_BUFFER_OVERFLOW;
572	break;
573	}
574	cch -= 3;
575	*pwch++ = 0xe0 \| (wc >> 12);
576	*pwch++ = 0x80 \| ((wc >> 6) & 0x3f);
577	*pwch++ = 0x80 \| (wc & 0x3f);
578	}
579	else
580	{
581	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
582	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
583	break;
584	}
585	}
586	else
587	{
588	if (wc >= 0xdc00)
589	{
590	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
591	rc = VERR_INVALID_UTF16_ENCODING;
592	break;
593	}
594	if (cwc <= 0)
595	{
596	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
597	rc = VERR_INVALID_UTF16_ENCODING;
598	break;
599	}
600	RTUTF16 wc2 = *pwsz++; cwc--;
601	wc2 = RT_BE2H_U16(wc2);
602	if (wc2 < 0xdc00 \|\| wc2 > 0xdfff)
603	{
604	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
605	rc = VERR_INVALID_UTF16_ENCODING;
606	break;
607	}
608	uint32_t CodePoint = 0x10000
609	+ ( ((wc & 0x3ff) << 10)
610	\| (wc2 & 0x3ff));
611	if (RT_UNLIKELY(cch < 4))
612	{
613	RTStrAssertMsgFailed(("Buffer overflow! 4\n"));
614	rc = VERR_BUFFER_OVERFLOW;
615	break;
616	}
617	cch -= 4;
618	*pwch++ = 0xf0 \| (CodePoint >> 18);
619	*pwch++ = 0x80 \| ((CodePoint >> 12) & 0x3f);
620	*pwch++ = 0x80 \| ((CodePoint >> 6) & 0x3f);
621	*pwch++ = 0x80 \| (CodePoint & 0x3f);
622	}
623	}
624
625	/* done */
626	*pwch = '\0';
627	pcch = (char )pwch - psz;
628	return rc;
629	}
630
631
632	/**
633	* Recodes an valid UTF-16LE string as UTF-8.
634	*
635	* @returns iprt status code.
636	* @param pwsz The UTF-16LE string.
637	* @param cwc The number of RTUTF16 characters to process from pwsz. The recoding
638	* will stop when cwc or '\\0' is reached.
639	* @param psz Where to store the UTF-8 string.
640	* @param cch The size of the UTF-8 buffer, excluding the terminator.
641	* @param pcch Where to store the number of octets actually encoded.
642	*
643	* @note rtUtf16LittleRecodeAsUtf8 == s/RT_LE2H_U16/RT_GE2H_U16/g
644	*/
645	static int rtUtf16LittleRecodeAsUtf8(PCRTUTF16 pwsz, size_t cwc, char psz, size_t cch, size_t pcch)
646	{
647	unsigned char pwch = (unsigned char )psz;
648	int rc = VINF_SUCCESS;
649	while (cwc > 0)
650	{
651	RTUTF16 wc = *pwsz++; cwc--;
652	if (!wc)
653	break;
654	wc = RT_LE2H_U16(wc);
655	if (wc < 0xd800 \|\| wc > 0xdfff)
656	{
657	if (wc < 0x80)
658	{
659	if (RT_UNLIKELY(cch < 1))
660	{
661	RTStrAssertMsgFailed(("Buffer overflow! 1\n"));
662	rc = VERR_BUFFER_OVERFLOW;
663	break;
664	}
665	cch--;
666	*pwch++ = (unsigned char)wc;
667	}
668	else if (wc < 0x800)
669	{
670	if (RT_UNLIKELY(cch < 2))
671	{
672	RTStrAssertMsgFailed(("Buffer overflow! 2\n"));
673	rc = VERR_BUFFER_OVERFLOW;
674	break;
675	}
676	cch -= 2;
677	*pwch++ = 0xc0 \| (wc >> 6);
678	*pwch++ = 0x80 \| (wc & 0x3f);
679	}
680	else if (wc < 0xfffe)
681	{
682	if (RT_UNLIKELY(cch < 3))
683	{
684	RTStrAssertMsgFailed(("Buffer overflow! 3\n"));
685	rc = VERR_BUFFER_OVERFLOW;
686	break;
687	}
688	cch -= 3;
689	*pwch++ = 0xe0 \| (wc >> 12);
690	*pwch++ = 0x80 \| ((wc >> 6) & 0x3f);
691	*pwch++ = 0x80 \| (wc & 0x3f);
692	}
693	else
694	{
695	RTStrAssertMsgFailed(("endian indicator! wc=%#x\n", wc));
696	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
697	break;
698	}
699	}
700	else
701	{
702	if (wc >= 0xdc00)
703	{
704	RTStrAssertMsgFailed(("Wrong 1st char in surrogate! wc=%#x\n", wc));
705	rc = VERR_INVALID_UTF16_ENCODING;
706	break;
707	}
708	if (cwc <= 0)
709	{
710	RTStrAssertMsgFailed(("Invalid length! wc=%#x\n", wc));
711	rc = VERR_INVALID_UTF16_ENCODING;
712	break;
713	}
714	RTUTF16 wc2 = *pwsz++; cwc--;
715	wc2 = RT_LE2H_U16(wc2);
716	if (wc2 < 0xdc00 \|\| wc2 > 0xdfff)
717	{
718	RTStrAssertMsgFailed(("Wrong 2nd char in surrogate! wc=%#x\n", wc));
719	rc = VERR_INVALID_UTF16_ENCODING;
720	break;
721	}
722	uint32_t CodePoint = 0x10000
723	+ ( ((wc & 0x3ff) << 10)
724	\| (wc2 & 0x3ff));
725	if (RT_UNLIKELY(cch < 4))
726	{
727	RTStrAssertMsgFailed(("Buffer overflow! 4\n"));
728	rc = VERR_BUFFER_OVERFLOW;
729	break;
730	}
731	cch -= 4;
732	*pwch++ = 0xf0 \| (CodePoint >> 18);
733	*pwch++ = 0x80 \| ((CodePoint >> 12) & 0x3f);
734	*pwch++ = 0x80 \| ((CodePoint >> 6) & 0x3f);
735	*pwch++ = 0x80 \| (CodePoint & 0x3f);
736	}
737	}
738
739	/* done */
740	*pwch = '\0';
741	pcch = (char )pwch - psz;
742	return rc;
743	}
744
745
746
747	RTDECL(int) RTUtf16ToUtf8Tag(PCRTUTF16 pwszString, char *ppszString, const char pszTag)
748	{
749	/*
750	* Validate input.
751	*/
752	AssertPtr(ppszString);
753	AssertPtr(pwszString);
754	*ppszString = NULL;
755
756	/*
757	* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
758	*/
759	size_t cch;
760	#ifdef RT_BIG_ENDIAN
761	int rc = rtUtf16BigCalcUtf8Length(pwszString, RTSTR_MAX, &cch);
762	#else
763	int rc = rtUtf16LittleCalcUtf8Length(pwszString, RTSTR_MAX, &cch);
764	#endif
765	if (RT_SUCCESS(rc))
766	{
767	/*
768	* Allocate buffer and recode it.
769	*/
770	char pszResult = (char )RTMemAllocTag(cch + 1, pszTag);
771	if (pszResult)
772	{
773	#ifdef RT_BIG_ENDIAN
774	rc = rtUtf16BigRecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cch, &cch);
775	#else
776	rc = rtUtf16LittleRecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cch, &cch);
777	#endif
778	if (RT_SUCCESS(rc))
779	{
780	*ppszString = pszResult;
781	return rc;
782	}
783
784	RTMemFree(pszResult);
785	}
786	else
787	rc = VERR_NO_STR_MEMORY;
788	}
789	return rc;
790	}
791	RT_EXPORT_SYMBOL(RTUtf16ToUtf8Tag);
792
793
794	RTDECL(int) RTUtf16BigToUtf8Tag(PCRTUTF16 pwszString, char *ppszString, const char pszTag)
795	{
796	/*
797	* Validate input.
798	*/
799	AssertPtr(ppszString);
800	AssertPtr(pwszString);
801	*ppszString = NULL;
802
803	/*
804	* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
805	*/
806	size_t cch;
807	int rc = rtUtf16BigCalcUtf8Length(pwszString, RTSTR_MAX, &cch);
808	if (RT_SUCCESS(rc))
809	{
810	/*
811	* Allocate buffer and recode it.
812	*/
813	char pszResult = (char )RTMemAllocTag(cch + 1, pszTag);
814	if (pszResult)
815	{
816	rc = rtUtf16BigRecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cch, &cch);
817	if (RT_SUCCESS(rc))
818	{
819	*ppszString = pszResult;
820	return rc;
821	}
822
823	RTMemFree(pszResult);
824	}
825	else
826	rc = VERR_NO_STR_MEMORY;
827	}
828	return rc;
829	}
830	RT_EXPORT_SYMBOL(RTUtf16BigToUtf8Tag);
831
832
833	RTDECL(int) RTUtf16LittleToUtf8Tag(PCRTUTF16 pwszString, char *ppszString, const char pszTag)
834	{
835	/*
836	* Validate input.
837	*/
838	AssertPtr(ppszString);
839	AssertPtr(pwszString);
840	*ppszString = NULL;
841
842	/*
843	* Validate the UTF-16LE string and calculate the length of the UTF-8 encoding of it.
844	*/
845	size_t cch;
846	int rc = rtUtf16LittleCalcUtf8Length(pwszString, RTSTR_MAX, &cch);
847	if (RT_SUCCESS(rc))
848	{
849	/*
850	* Allocate buffer and recode it.
851	*/
852	char pszResult = (char )RTMemAllocTag(cch + 1, pszTag);
853	if (pszResult)
854	{
855	rc = rtUtf16LittleRecodeAsUtf8(pwszString, RTSTR_MAX, pszResult, cch, &cch);
856	if (RT_SUCCESS(rc))
857	{
858	*ppszString = pszResult;
859	return rc;
860	}
861
862	RTMemFree(pszResult);
863	}
864	else
865	rc = VERR_NO_STR_MEMORY;
866	}
867	return rc;
868	}
869	RT_EXPORT_SYMBOL(RTUtf16LittleToUtf8Tag);
870
871
872	RTDECL(int) RTUtf16ToUtf8ExTag(PCRTUTF16 pwszString, size_t cwcString, char *ppsz, size_t cch, size_t pcch, const char *pszTag)
873	{
874	/*
875	* Validate input.
876	*/
877	AssertPtr(pwszString);
878	AssertPtr(ppsz);
879	AssertPtrNull(pcch);
880
881	/*
882	* Validate the UTF-16 string and calculate the length of the UTF-8 encoding of it.
883	*/
884	size_t cchResult;
885	#ifdef RT_BIG_ENDIAN
886	int rc = rtUtf16BigCalcUtf8Length(pwszString, cwcString, &cchResult);
887	#else
888	int rc = rtUtf16LittleCalcUtf8Length(pwszString, cwcString, &cchResult);
889	#endif
890	if (RT_SUCCESS(rc))
891	{
892	if (pcch)
893	*pcch = cchResult;
894
895	/*
896	* Check buffer size / Allocate buffer and recode it.
897	*/
898	bool fShouldFree;
899	char *pszResult;
900	if (cch > 0 && *ppsz)
901	{
902	fShouldFree = false;
903	if (RT_UNLIKELY(cch <= cchResult))
904	return VERR_BUFFER_OVERFLOW;
905	pszResult = *ppsz;
906	}
907	else
908	{
909	*ppsz = NULL;
910	fShouldFree = true;
911	cch = RT_MAX(cch, cchResult + 1);
912	pszResult = (char *)RTStrAllocTag(cch, pszTag);
913	}
914	if (pszResult)
915	{
916	#ifdef RT_BIG_ENDIAN
917	rc = rtUtf16BigRecodeAsUtf8(pwszString, cwcString, pszResult, cch - 1, &cch);
918	#else
919	rc = rtUtf16LittleRecodeAsUtf8(pwszString, cwcString, pszResult, cch - 1, &cch);
920	#endif
921	if (RT_SUCCESS(rc))
922	{
923	*ppsz = pszResult;
924	return rc;
925	}
926
927	if (fShouldFree)
928	RTStrFree(pszResult);
929	}
930	else
931	rc = VERR_NO_STR_MEMORY;
932	}
933	return rc;
934	}
935	RT_EXPORT_SYMBOL(RTUtf16ToUtf8ExTag);
936
937
938	RTDECL(int) RTUtf16BigToUtf8ExTag(PCRTUTF16 pwszString, size_t cwcString, char *ppsz, size_t cch, size_t pcch, const char *pszTag)
939	{
940	/*
941	* Validate input.
942	*/
943	AssertPtr(pwszString);
944	AssertPtr(ppsz);
945	AssertPtrNull(pcch);
946
947	/*
948	* Validate the UTF-16BE string and calculate the length of the UTF-8 encoding of it.
949	*/
950	size_t cchResult;
951	int rc = rtUtf16BigCalcUtf8Length(pwszString, cwcString, &cchResult);
952	if (RT_SUCCESS(rc))
953	{
954	if (pcch)
955	*pcch = cchResult;
956
957	/*
958	* Check buffer size / Allocate buffer and recode it.
959	*/
960	bool fShouldFree;
961	char *pszResult;
962	if (cch > 0 && *ppsz)
963	{
964	fShouldFree = false;
965	if (RT_UNLIKELY(cch <= cchResult))
966	return VERR_BUFFER_OVERFLOW;
967	pszResult = *ppsz;
968	}
969	else
970	{
971	*ppsz = NULL;
972	fShouldFree = true;
973	cch = RT_MAX(cch, cchResult + 1);
974	pszResult = (char *)RTStrAllocTag(cch, pszTag);
975	}
976	if (pszResult)
977	{
978	rc = rtUtf16BigRecodeAsUtf8(pwszString, cwcString, pszResult, cch - 1, &cch);
979	if (RT_SUCCESS(rc))
980	{
981	*ppsz = pszResult;
982	return rc;
983	}
984
985	if (fShouldFree)
986	RTStrFree(pszResult);
987	}
988	else
989	rc = VERR_NO_STR_MEMORY;
990	}
991	return rc;
992	}
993	RT_EXPORT_SYMBOL(RTUtf16BigToUtf8ExTag);
994
995
996	RTDECL(int) RTUtf16LittleToUtf8ExTag(PCRTUTF16 pwszString, size_t cwcString, char *ppsz, size_t cch, size_t pcch,
997	const char *pszTag)
998	{
999	/*
1000	* Validate input.
1001	*/
1002	AssertPtr(pwszString);
1003	AssertPtr(ppsz);
1004	AssertPtrNull(pcch);
1005
1006	/*
1007	* Validate the UTF-16LE string and calculate the length of the UTF-8 encoding of it.
1008	*/
1009	size_t cchResult;
1010	int rc = rtUtf16LittleCalcUtf8Length(pwszString, cwcString, &cchResult);
1011	if (RT_SUCCESS(rc))
1012	{
1013	if (pcch)
1014	*pcch = cchResult;
1015
1016	/*
1017	* Check buffer size / Allocate buffer and recode it.
1018	*/
1019	bool fShouldFree;
1020	char *pszResult;
1021	if (cch > 0 && *ppsz)
1022	{
1023	fShouldFree = false;
1024	if (RT_UNLIKELY(cch <= cchResult))
1025	return VERR_BUFFER_OVERFLOW;
1026	pszResult = *ppsz;
1027	}
1028	else
1029	{
1030	*ppsz = NULL;
1031	fShouldFree = true;
1032	cch = RT_MAX(cch, cchResult + 1);
1033	pszResult = (char *)RTStrAllocTag(cch, pszTag);
1034	}
1035	if (pszResult)
1036	{
1037	rc = rtUtf16LittleRecodeAsUtf8(pwszString, cwcString, pszResult, cch - 1, &cch);
1038	if (RT_SUCCESS(rc))
1039	{
1040	*ppsz = pszResult;
1041	return rc;
1042	}
1043
1044	if (fShouldFree)
1045	RTStrFree(pszResult);
1046	}
1047	else
1048	rc = VERR_NO_STR_MEMORY;
1049	}
1050	return rc;
1051	}
1052	RT_EXPORT_SYMBOL(RTUtf16BigToUtf8ExTag);
1053
1054
1055	RTDECL(size_t) RTUtf16CalcUtf8Len(PCRTUTF16 pwsz)
1056	{
1057	size_t cch;
1058	#ifdef RT_BIG_ENDIAN
1059	int rc = rtUtf16BigCalcUtf8Length(pwsz, RTSTR_MAX, &cch);
1060	#else
1061	int rc = rtUtf16LittleCalcUtf8Length(pwsz, RTSTR_MAX, &cch);
1062	#endif
1063	return RT_SUCCESS(rc) ? cch : 0;
1064	}
1065	RT_EXPORT_SYMBOL(RTUtf16CalcUtf8Len);
1066
1067
1068	RTDECL(size_t) RTUtf16BigCalcUtf8Len(PCRTUTF16 pwsz)
1069	{
1070	size_t cch;
1071	int rc = rtUtf16BigCalcUtf8Length(pwsz, RTSTR_MAX, &cch);
1072	return RT_SUCCESS(rc) ? cch : 0;
1073	}
1074	RT_EXPORT_SYMBOL(RTUtf16BigCalcUtf8Len);
1075
1076
1077	RTDECL(size_t) RTUtf16LittleCalcUtf8Len(PCRTUTF16 pwsz)
1078	{
1079	size_t cch;
1080	int rc = rtUtf16LittleCalcUtf8Length(pwsz, RTSTR_MAX, &cch);
1081	return RT_SUCCESS(rc) ? cch : 0;
1082	}
1083	RT_EXPORT_SYMBOL(RTUtf16LittleCalcUtf8Len);
1084
1085
1086	RTDECL(int) RTUtf16CalcUtf8LenEx(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
1087	{
1088	size_t cch;
1089	#ifdef RT_BIG_ENDIAN
1090	int rc = rtUtf16BigCalcUtf8Length(pwsz, cwc, &cch);
1091	#else
1092	int rc = rtUtf16LittleCalcUtf8Length(pwsz, cwc, &cch);
1093	#endif
1094	if (pcch)
1095	*pcch = RT_SUCCESS(rc) ? cch : ~(size_t)0;
1096	return rc;
1097	}
1098	RT_EXPORT_SYMBOL(RTUtf16CalcUtf8LenEx);
1099
1100
1101	RTDECL(int) RTUtf16BigCalcUtf8LenEx(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
1102	{
1103	size_t cch;
1104	int rc = rtUtf16BigCalcUtf8Length(pwsz, cwc, &cch);
1105	if (pcch)
1106	*pcch = RT_SUCCESS(rc) ? cch : ~(size_t)0;
1107	return rc;
1108	}
1109	RT_EXPORT_SYMBOL(RTUtf16BigCalcUtf8LenEx);
1110
1111
1112	RTDECL(int) RTUtf16LittleCalcUtf8LenEx(PCRTUTF16 pwsz, size_t cwc, size_t *pcch)
1113	{
1114	size_t cch;
1115	int rc = rtUtf16LittleCalcUtf8Length(pwsz, cwc, &cch);
1116	if (pcch)
1117	*pcch = RT_SUCCESS(rc) ? cch : ~(size_t)0;
1118	return rc;
1119	}
1120	RT_EXPORT_SYMBOL(RTUtf16LittleCalcUtf8LenEx);
1121
1122
1123	RTDECL(RTUNICP) RTUtf16GetCpInternal(PCRTUTF16 pwsz)
1124	{
1125	const RTUTF16 wc = *pwsz;
1126
1127	/* simple */
1128	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
1129	return wc;
1130	if (wc < 0xfffe)
1131	{
1132	/* surrogate pair */
1133	if (wc < 0xdc00)
1134	{
1135	const RTUTF16 wc2 = pwsz[1];
1136	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
1137	{
1138	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
1139	return uc;
1140	}
1141
1142	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
1143	}
1144	else
1145	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
1146	}
1147	else
1148	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
1149	return RTUNICP_INVALID;
1150	}
1151	RT_EXPORT_SYMBOL(RTUtf16GetCpInternal);
1152
1153
1154	RTDECL(int) RTUtf16GetCpExInternal(PCRTUTF16 *ppwsz, PRTUNICP pCp)
1155	{
1156	const RTUTF16 wc = **ppwsz;
1157
1158	/* simple */
1159	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
1160	{
1161	(*ppwsz)++;
1162	*pCp = wc;
1163	return VINF_SUCCESS;
1164	}
1165
1166	int rc;
1167	if (wc < 0xfffe)
1168	{
1169	/* surrogate pair */
1170	if (wc < 0xdc00)
1171	{
1172	const RTUTF16 wc2 = (*ppwsz)[1];
1173	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
1174	{
1175	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
1176	*pCp = uc;
1177	(*ppwsz) += 2;
1178	return VINF_SUCCESS;
1179	}
1180
1181	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
1182	}
1183	else
1184	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
1185	rc = VERR_INVALID_UTF16_ENCODING;
1186	}
1187	else
1188	{
1189	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
1190	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
1191	}
1192	*pCp = RTUNICP_INVALID;
1193	(*ppwsz)++;
1194	return rc;
1195	}
1196	RT_EXPORT_SYMBOL(RTUtf16GetCpExInternal);
1197
1198
1199	RTDECL(int) RTUtf16GetCpNExInternal(PCRTUTF16 ppwsz, size_t pcwc, PRTUNICP pCp)
1200	{
1201	int rc;
1202	const size_t cwc = *pcwc;
1203	if (cwc > 0)
1204	{
1205	PCRTUTF16 pwsz = *ppwsz;
1206	const RTUTF16 wc = **ppwsz;
1207
1208	/* simple */
1209	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
1210	{
1211	*pCp = wc;
1212	*pcwc = cwc - 1;
1213	*ppwsz = pwsz + 1;
1214	return VINF_SUCCESS;
1215	}
1216
1217	if (wc < 0xfffe)
1218	{
1219	/* surrogate pair */
1220	if (wc < 0xdc00)
1221	{
1222	if (cwc >= 2)
1223	{
1224	const RTUTF16 wc2 = pwsz[1];
1225	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
1226	{
1227	*pCp = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
1228	*pcwc = cwc - 2;
1229	*ppwsz = pwsz + 2;
1230	return VINF_SUCCESS;
1231	}
1232
1233	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
1234	}
1235	else
1236	RTStrAssertMsgFailed(("wc=%#08x - incomplete surrogate pair\n", wc));
1237	}
1238	else
1239	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
1240	rc = VERR_INVALID_UTF16_ENCODING;
1241	}
1242	else
1243	{
1244	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
1245	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
1246	}
1247	*pcwc = cwc - 1;
1248	*ppwsz = pwsz + 1;
1249	}
1250	else
1251	rc = VERR_END_OF_STRING;
1252	*pCp = RTUNICP_INVALID;
1253	return rc;
1254	}
1255	RT_EXPORT_SYMBOL(RTUtf16GetCpNExInternal);
1256
1257
1258	RTDECL(int) RTUtf16BigGetCpExInternal(PCRTUTF16 *ppwsz, PRTUNICP pCp)
1259	{
1260	const RTUTF16 wc = RT_BE2H_U16(**ppwsz);
1261
1262	/* simple */
1263	if (wc < 0xd800 \|\| (wc > 0xdfff && wc < 0xfffe))
1264	{
1265	(*ppwsz)++;
1266	*pCp = wc;
1267	return VINF_SUCCESS;
1268	}
1269
1270	int rc;
1271	if (wc < 0xfffe)
1272	{
1273	/* surrogate pair */
1274	if (wc < 0xdc00)
1275	{
1276	const RTUTF16 wc2 = RT_BE2H_U16((*ppwsz)[1]);
1277	if (wc2 >= 0xdc00 && wc2 <= 0xdfff)
1278	{
1279	RTUNICP uc = 0x10000 + (((wc & 0x3ff) << 10) \| (wc2 & 0x3ff));
1280	*pCp = uc;
1281	(*ppwsz) += 2;
1282	return VINF_SUCCESS;
1283	}
1284
1285	RTStrAssertMsgFailed(("wc=%#08x wc2=%#08x - invalid 2nd char in surrogate pair\n", wc, wc2));
1286	}
1287	else
1288	RTStrAssertMsgFailed(("wc=%#08x - invalid surrogate pair order\n", wc));
1289	rc = VERR_INVALID_UTF16_ENCODING;
1290	}
1291	else
1292	{
1293	RTStrAssertMsgFailed(("wc=%#08x - endian indicator\n", wc));
1294	rc = VERR_CODE_POINT_ENDIAN_INDICATOR;
1295	}
1296	*pCp = RTUNICP_INVALID;
1297	(*ppwsz)++;
1298	return rc;
1299	}
1300	RT_EXPORT_SYMBOL(RTUtf16GetCpExInternal);
1301
1302
1303	RTDECL(PRTUTF16) RTUtf16PutCpInternal(PRTUTF16 pwsz, RTUNICP CodePoint)
1304	{
1305	/* simple */
1306	if ( CodePoint < 0xd800
1307	\|\| ( CodePoint > 0xdfff
1308	&& CodePoint < 0xfffe))
1309	{
1310	*pwsz++ = (RTUTF16)CodePoint;
1311	return pwsz;
1312	}
1313
1314	/* surrogate pair */
1315	if (CodePoint >= 0x10000 && CodePoint <= 0x0010ffff)
1316	{
1317	CodePoint -= 0x10000;
1318	*pwsz++ = 0xd800 \| (CodePoint >> 10);
1319	*pwsz++ = 0xdc00 \| (CodePoint & 0x3ff);
1320	return pwsz;
1321	}
1322
1323	/* invalid code point. */
1324	RTStrAssertMsgFailed(("Invalid codepoint %#x\n", CodePoint));
1325	*pwsz++ = 0x7f;
1326	return pwsz;
1327	}
1328	RT_EXPORT_SYMBOL(RTUtf16PutCpInternal);
1329

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

source: vbox/trunk/src/VBox/Runtime/common/string/utf-16.cpp@ 96563

Download in other formats: