1 | /* $Id: string.cpp 83785 2020-04-17 23:34:58Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * MS COM / XPCOM Abstraction Layer - UTF-8 and UTF-16 string classes.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2006-2020 Oracle Corporation
|
---|
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 (GPL) as published by the Free Software
|
---|
13 | * Foundation, in version 2 as it comes in the "COPYING" file of the
|
---|
14 | * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
|
---|
15 | * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
|
---|
16 | */
|
---|
17 |
|
---|
18 | #include "VBox/com/string.h"
|
---|
19 |
|
---|
20 | #include <iprt/err.h>
|
---|
21 | #include <iprt/path.h>
|
---|
22 | #include <iprt/log.h>
|
---|
23 | #include <iprt/string.h>
|
---|
24 | #include <iprt/uni.h>
|
---|
25 |
|
---|
26 | namespace com
|
---|
27 | {
|
---|
28 |
|
---|
29 | // BSTR representing a null wide char with 32 bits of length prefix (0);
|
---|
30 | // this will work on Windows as well as other platforms where BSTR does
|
---|
31 | // not use length prefixes
|
---|
32 | const OLECHAR g_achEmptyBstr[3] = { 0, 0, 0 };
|
---|
33 | const BSTR g_bstrEmpty = (BSTR)&g_achEmptyBstr[2];
|
---|
34 |
|
---|
35 | /* static */
|
---|
36 | const Bstr Bstr::Empty; /* default ctor is OK */
|
---|
37 |
|
---|
38 |
|
---|
39 | Bstr &Bstr::printf(const char *pszFormat, ...)
|
---|
40 | {
|
---|
41 | va_list va;
|
---|
42 | va_start(va, pszFormat);
|
---|
43 | HRESULT hrc = printfVNoThrow(pszFormat, va);
|
---|
44 | va_end(va);
|
---|
45 | if (hrc == S_OK)
|
---|
46 | { /* likely */ }
|
---|
47 | else
|
---|
48 | throw std::bad_alloc();
|
---|
49 | return *this;
|
---|
50 | }
|
---|
51 |
|
---|
52 | HRESULT Bstr::printfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
|
---|
53 | {
|
---|
54 | va_list va;
|
---|
55 | va_start(va, pszFormat);
|
---|
56 | HRESULT hrc = printfVNoThrow(pszFormat, va);
|
---|
57 | va_end(va);
|
---|
58 | return hrc;
|
---|
59 | }
|
---|
60 |
|
---|
61 |
|
---|
62 | Bstr &Bstr::printfV(const char *pszFormat, va_list va)
|
---|
63 | {
|
---|
64 | HRESULT hrc = printfVNoThrow(pszFormat, va);
|
---|
65 | if (hrc == S_OK)
|
---|
66 | { /* likely */ }
|
---|
67 | else
|
---|
68 | throw std::bad_alloc();
|
---|
69 | return *this;
|
---|
70 | }
|
---|
71 |
|
---|
72 | struct BSTRNOTHROW
|
---|
73 | {
|
---|
74 | Bstr *pThis;
|
---|
75 | size_t cwcAlloc;
|
---|
76 | size_t offDst;
|
---|
77 | HRESULT hrc;
|
---|
78 | };
|
---|
79 |
|
---|
80 | /**
|
---|
81 | * Callback used with RTStrFormatV by Bstr::printfVNoThrow.
|
---|
82 | *
|
---|
83 | * @returns The number of bytes added (not used).
|
---|
84 | *
|
---|
85 | * @param pvArg Pointer to a BSTRNOTHROW structure.
|
---|
86 | * @param pachChars The characters to append.
|
---|
87 | * @param cbChars The number of characters. 0 on the final callback.
|
---|
88 | */
|
---|
89 | /*static*/ DECLCALLBACK(size_t)
|
---|
90 | Bstr::printfOutputCallbackNoThrow(void *pvArg, const char *pachChars, size_t cbChars) RT_NOEXCEPT
|
---|
91 | {
|
---|
92 | BSTRNOTHROW *pArgs = (BSTRNOTHROW *)pvArg;
|
---|
93 | if (cbChars)
|
---|
94 | {
|
---|
95 | size_t cwcAppend;
|
---|
96 | int rc = ::RTStrCalcUtf16LenEx(pachChars, cbChars, &cwcAppend);
|
---|
97 | AssertRCReturnStmt(rc, pArgs->hrc = E_UNEXPECTED, 0);
|
---|
98 |
|
---|
99 | /*
|
---|
100 | * Ensure we've got sufficient memory.
|
---|
101 | */
|
---|
102 | Bstr *pThis = pArgs->pThis;
|
---|
103 | size_t const cwcBoth = pArgs->offDst + cwcAppend;
|
---|
104 | if (cwcBoth >= pArgs->cwcAlloc)
|
---|
105 | {
|
---|
106 | if (pArgs->hrc == S_OK)
|
---|
107 | {
|
---|
108 | /* Double the buffer size, if it's less that _1M. Align sizes like
|
---|
109 | for append. */
|
---|
110 | size_t cwcAlloc = RT_ALIGN_Z(pArgs->cwcAlloc, 128);
|
---|
111 | cwcAlloc += RT_MIN(cwcAlloc, _1M);
|
---|
112 | if (cwcAlloc <= cwcBoth)
|
---|
113 | cwcAlloc = RT_ALIGN_Z(cwcBoth + 1, 512);
|
---|
114 | pArgs->hrc = pThis->reserveNoThrow(cwcAlloc, true /*fForce*/);
|
---|
115 | AssertMsgReturn(pArgs->hrc == S_OK, ("cwcAlloc=%#zx\n", cwcAlloc), 0);
|
---|
116 | pArgs->cwcAlloc = cwcAlloc;
|
---|
117 | }
|
---|
118 | else
|
---|
119 | return 0;
|
---|
120 | }
|
---|
121 |
|
---|
122 | /*
|
---|
123 | * Do the conversion.
|
---|
124 | */
|
---|
125 | PRTUTF16 pwszDst = pThis->m_bstr + pArgs->offDst;
|
---|
126 | Assert(pArgs->cwcAlloc > pArgs->offDst);
|
---|
127 | rc = ::RTStrToUtf16Ex(pachChars, cbChars, &pwszDst, pArgs->cwcAlloc - pArgs->offDst, &cwcAppend);
|
---|
128 | AssertRCReturnStmt(rc, pArgs->hrc = E_UNEXPECTED, 0);
|
---|
129 | pArgs->offDst += cwcAppend;
|
---|
130 | }
|
---|
131 | return cbChars;
|
---|
132 | }
|
---|
133 |
|
---|
134 | HRESULT Bstr::printfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
|
---|
135 | {
|
---|
136 | cleanup();
|
---|
137 |
|
---|
138 | BSTRNOTHROW Args = { this, 0, 0, S_OK };
|
---|
139 | RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
|
---|
140 | if (Args.hrc == S_OK)
|
---|
141 | {
|
---|
142 | Args.hrc = joltNoThrow(Args.offDst);
|
---|
143 | if (Args.hrc == S_OK)
|
---|
144 | return S_OK;
|
---|
145 | }
|
---|
146 |
|
---|
147 | cleanup();
|
---|
148 | return Args.hrc;
|
---|
149 | }
|
---|
150 |
|
---|
151 | void Bstr::copyFromN(const char *a_pszSrc, size_t a_cchMax)
|
---|
152 | {
|
---|
153 | /*
|
---|
154 | * Initialize m_bstr first in case of throws further down in the code, then
|
---|
155 | * check for empty input (m_bstr == NULL means empty, there are no NULL
|
---|
156 | * strings).
|
---|
157 | */
|
---|
158 | m_bstr = NULL;
|
---|
159 | if (!a_cchMax || !a_pszSrc || !*a_pszSrc)
|
---|
160 | return;
|
---|
161 |
|
---|
162 | /*
|
---|
163 | * Calculate the length and allocate a BSTR string buffer of the right
|
---|
164 | * size, i.e. optimize heap usage.
|
---|
165 | */
|
---|
166 | size_t cwc;
|
---|
167 | int vrc = ::RTStrCalcUtf16LenEx(a_pszSrc, a_cchMax, &cwc);
|
---|
168 | if (RT_SUCCESS(vrc))
|
---|
169 | {
|
---|
170 | m_bstr = ::SysAllocStringByteLen(NULL, (unsigned)(cwc * sizeof(OLECHAR)));
|
---|
171 | if (RT_LIKELY(m_bstr))
|
---|
172 | {
|
---|
173 | PRTUTF16 pwsz = (PRTUTF16)m_bstr;
|
---|
174 | vrc = ::RTStrToUtf16Ex(a_pszSrc, a_cchMax, &pwsz, cwc + 1, NULL);
|
---|
175 | if (RT_SUCCESS(vrc))
|
---|
176 | return;
|
---|
177 |
|
---|
178 | /* This should not happen! */
|
---|
179 | AssertRC(vrc);
|
---|
180 | cleanup();
|
---|
181 | }
|
---|
182 | }
|
---|
183 | else /* ASSUME: input is valid Utf-8. Fake out of memory error. */
|
---|
184 | AssertLogRelMsgFailed(("%Rrc %.*Rhxs\n", vrc, RTStrNLen(a_pszSrc, a_cchMax), a_pszSrc));
|
---|
185 | throw std::bad_alloc();
|
---|
186 | }
|
---|
187 |
|
---|
188 | int Bstr::compareUtf8(const char *a_pszRight, CaseSensitivity a_enmCase /*= CaseSensitive*/) const
|
---|
189 | {
|
---|
190 | PCRTUTF16 pwszLeft = m_bstr;
|
---|
191 |
|
---|
192 | /*
|
---|
193 | * Special case for null/empty strings. Unlike RTUtf16Cmp we
|
---|
194 | * treat null and empty equally.
|
---|
195 | */
|
---|
196 | if (!pwszLeft)
|
---|
197 | return !a_pszRight || *a_pszRight == '\0' ? 0 : -1;
|
---|
198 | if (!a_pszRight)
|
---|
199 | return *pwszLeft == '\0' ? 0 : 1;
|
---|
200 |
|
---|
201 | /*
|
---|
202 | * Compare with a UTF-8 string by enumerating them char by char.
|
---|
203 | */
|
---|
204 | for (;;)
|
---|
205 | {
|
---|
206 | RTUNICP ucLeft;
|
---|
207 | int rc = RTUtf16GetCpEx(&pwszLeft, &ucLeft);
|
---|
208 | AssertRCReturn(rc, 1);
|
---|
209 |
|
---|
210 | RTUNICP ucRight;
|
---|
211 | rc = RTStrGetCpEx(&a_pszRight, &ucRight);
|
---|
212 | AssertRCReturn(rc, -1);
|
---|
213 | if (ucLeft == ucRight)
|
---|
214 | {
|
---|
215 | if (ucLeft)
|
---|
216 | continue;
|
---|
217 | return 0;
|
---|
218 | }
|
---|
219 |
|
---|
220 | if (a_enmCase == CaseInsensitive)
|
---|
221 | {
|
---|
222 | if (RTUniCpToUpper(ucLeft) == RTUniCpToUpper(ucRight))
|
---|
223 | continue;
|
---|
224 | if (RTUniCpToLower(ucLeft) == RTUniCpToLower(ucRight))
|
---|
225 | continue;
|
---|
226 | }
|
---|
227 |
|
---|
228 | return ucLeft < ucRight ? -1 : 1;
|
---|
229 | }
|
---|
230 | }
|
---|
231 |
|
---|
232 |
|
---|
233 | #ifndef VBOX_WITH_XPCOM
|
---|
234 |
|
---|
235 | HRESULT Bstr::joltNoThrow(ssize_t cwcNew /* = -1*/) RT_NOEXCEPT
|
---|
236 | {
|
---|
237 | if (m_bstr)
|
---|
238 | {
|
---|
239 | size_t const cwcAlloc = ::SysStringLen(m_bstr);
|
---|
240 | size_t const cwcActual = cwcNew < 0 ? ::RTUtf16Len(m_bstr) : (size_t)cwcNew;
|
---|
241 | Assert(cwcNew < 0 || cwcActual == ::RTUtf16Len(m_bstr));
|
---|
242 | if (cwcActual != cwcAlloc)
|
---|
243 | {
|
---|
244 | Assert(cwcActual <= cwcAlloc);
|
---|
245 | Assert((unsigned int)cwcActual == cwcActual);
|
---|
246 |
|
---|
247 | /* Official way: Reallocate the string. We could of course just update the size-prefix if we dared... */
|
---|
248 | if (!::SysReAllocStringLen(&m_bstr, NULL, (unsigned int)cwcActual))
|
---|
249 | {
|
---|
250 | AssertFailed();
|
---|
251 | return E_OUTOFMEMORY;
|
---|
252 | }
|
---|
253 | }
|
---|
254 | }
|
---|
255 | else
|
---|
256 | Assert(cwcNew <= 0);
|
---|
257 | return S_OK;
|
---|
258 | }
|
---|
259 |
|
---|
260 |
|
---|
261 | void Bstr::jolt(ssize_t cwcNew /* = -1*/)
|
---|
262 | {
|
---|
263 | HRESULT hrc = joltNoThrow(cwcNew);
|
---|
264 | if (hrc != S_OK)
|
---|
265 | throw std::bad_alloc();
|
---|
266 | }
|
---|
267 |
|
---|
268 | #endif /* !VBOX_WITH_XPCOM */
|
---|
269 |
|
---|
270 |
|
---|
271 | HRESULT Bstr::reserveNoThrow(size_t cwcMin, bool fForce /*= false*/) RT_NOEXCEPT
|
---|
272 | {
|
---|
273 | /* If not forcing the string to the cwcMin length, check cwcMin against the
|
---|
274 | current string length: */
|
---|
275 | if (!fForce)
|
---|
276 | {
|
---|
277 | size_t cwcCur = m_bstr ? ::SysStringLen(m_bstr) : 0;
|
---|
278 | if (cwcCur >= cwcMin)
|
---|
279 | return S_OK;
|
---|
280 | }
|
---|
281 |
|
---|
282 | /* The documentation for SysReAllocStringLen hints about it being allergic
|
---|
283 | to NULL in some way or another, so we call SysAllocStringLen directly
|
---|
284 | when appropriate: */
|
---|
285 | if (m_bstr)
|
---|
286 | AssertReturn(::SysReAllocStringLen(&m_bstr, NULL, (unsigned int)cwcMin) != FALSE, E_OUTOFMEMORY);
|
---|
287 | else if (cwcMin > 0)
|
---|
288 | {
|
---|
289 | m_bstr = ::SysAllocStringLen(NULL, (unsigned int)cwcMin);
|
---|
290 | AssertReturn(m_bstr, E_OUTOFMEMORY);
|
---|
291 | }
|
---|
292 |
|
---|
293 | return S_OK;
|
---|
294 | }
|
---|
295 |
|
---|
296 |
|
---|
297 | void Bstr::reserve(size_t cwcMin, bool fForce /*= false*/)
|
---|
298 | {
|
---|
299 | HRESULT hrc = reserveNoThrow(cwcMin, fForce);
|
---|
300 | if (hrc != S_OK)
|
---|
301 | throw std::bad_alloc();
|
---|
302 | }
|
---|
303 |
|
---|
304 |
|
---|
305 | Bstr &Bstr::append(const Bstr &rThat)
|
---|
306 | {
|
---|
307 | if (rThat.isNotEmpty())
|
---|
308 | return appendWorkerUtf16(rThat.m_bstr, rThat.length());
|
---|
309 | return *this;
|
---|
310 | }
|
---|
311 |
|
---|
312 |
|
---|
313 | HRESULT Bstr::appendNoThrow(const Bstr &rThat) RT_NOEXCEPT
|
---|
314 | {
|
---|
315 | if (rThat.isNotEmpty())
|
---|
316 | return appendWorkerUtf16NoThrow(rThat.m_bstr, rThat.length());
|
---|
317 | return S_OK;
|
---|
318 | }
|
---|
319 |
|
---|
320 |
|
---|
321 | Bstr &Bstr::append(const RTCString &rThat)
|
---|
322 | {
|
---|
323 | if (rThat.isNotEmpty())
|
---|
324 | return appendWorkerUtf8(rThat.c_str(), rThat.length());
|
---|
325 | return *this;
|
---|
326 | }
|
---|
327 |
|
---|
328 |
|
---|
329 | HRESULT Bstr::appendNoThrow(const RTCString &rThat) RT_NOEXCEPT
|
---|
330 | {
|
---|
331 | if (rThat.isNotEmpty())
|
---|
332 | return appendWorkerUtf8NoThrow(rThat.c_str(), rThat.length());
|
---|
333 | return S_OK;
|
---|
334 | }
|
---|
335 |
|
---|
336 |
|
---|
337 | Bstr &Bstr::append(CBSTR pwszSrc)
|
---|
338 | {
|
---|
339 | if (pwszSrc && *pwszSrc)
|
---|
340 | return appendWorkerUtf16(pwszSrc, RTUtf16Len(pwszSrc));
|
---|
341 | return *this;
|
---|
342 | }
|
---|
343 |
|
---|
344 |
|
---|
345 | HRESULT Bstr::appendNoThrow(CBSTR pwszSrc) RT_NOEXCEPT
|
---|
346 | {
|
---|
347 | if (pwszSrc && *pwszSrc)
|
---|
348 | return appendWorkerUtf16NoThrow(pwszSrc, RTUtf16Len(pwszSrc));
|
---|
349 | return S_OK;
|
---|
350 | }
|
---|
351 |
|
---|
352 |
|
---|
353 | Bstr &Bstr::append(const char *pszSrc)
|
---|
354 | {
|
---|
355 | if (pszSrc && *pszSrc)
|
---|
356 | return appendWorkerUtf8(pszSrc, strlen(pszSrc));
|
---|
357 | return *this;
|
---|
358 | }
|
---|
359 |
|
---|
360 |
|
---|
361 | HRESULT Bstr::appendNoThrow(const char *pszSrc) RT_NOEXCEPT
|
---|
362 | {
|
---|
363 | if (pszSrc && *pszSrc)
|
---|
364 | return appendWorkerUtf8NoThrow(pszSrc, strlen(pszSrc));
|
---|
365 | return S_OK;
|
---|
366 | }
|
---|
367 |
|
---|
368 |
|
---|
369 | Bstr &Bstr::append(const Bstr &rThat, size_t offStart, size_t cwcMax /*= RTSTR_MAX*/)
|
---|
370 | {
|
---|
371 | size_t cwcSrc = rThat.length();
|
---|
372 | if (offStart < cwcSrc)
|
---|
373 | return appendWorkerUtf16(rThat.raw() + offStart, RT_MIN(cwcSrc - offStart, cwcMax));
|
---|
374 | return *this;
|
---|
375 | }
|
---|
376 |
|
---|
377 |
|
---|
378 | HRESULT Bstr::appendNoThrow(const Bstr &rThat, size_t offStart, size_t cwcMax /*= RTSTR_MAX*/) RT_NOEXCEPT
|
---|
379 | {
|
---|
380 | size_t cwcSrc = rThat.length();
|
---|
381 | if (offStart < cwcSrc)
|
---|
382 | return appendWorkerUtf16NoThrow(rThat.raw() + offStart, RT_MIN(cwcSrc - offStart, cwcMax));
|
---|
383 | return S_OK;
|
---|
384 | }
|
---|
385 |
|
---|
386 |
|
---|
387 | Bstr &Bstr::append(const RTCString &rThat, size_t offStart, size_t cchMax /*= RTSTR_MAX*/)
|
---|
388 | {
|
---|
389 | if (offStart < rThat.length())
|
---|
390 | return appendWorkerUtf8(rThat.c_str() + offStart, RT_MIN(rThat.length() - offStart, cchMax));
|
---|
391 | return *this;
|
---|
392 | }
|
---|
393 |
|
---|
394 |
|
---|
395 | HRESULT Bstr::appendNoThrow(const RTCString &rThat, size_t offStart, size_t cchMax /*= RTSTR_MAX*/) RT_NOEXCEPT
|
---|
396 | {
|
---|
397 | if (offStart < rThat.length())
|
---|
398 | return appendWorkerUtf8NoThrow(rThat.c_str() + offStart, RT_MIN(rThat.length() - offStart, cchMax));
|
---|
399 | return S_OK;
|
---|
400 | }
|
---|
401 |
|
---|
402 |
|
---|
403 | Bstr &Bstr::append(CBSTR pwszThat, size_t cchMax)
|
---|
404 | {
|
---|
405 | return appendWorkerUtf16(pwszThat, RTUtf16NLen(pwszThat, cchMax));
|
---|
406 | }
|
---|
407 |
|
---|
408 |
|
---|
409 | HRESULT Bstr::appendNoThrow(CBSTR pwszThat, size_t cchMax) RT_NOEXCEPT
|
---|
410 | {
|
---|
411 | return appendWorkerUtf16NoThrow(pwszThat, RTUtf16NLen(pwszThat, cchMax));
|
---|
412 | }
|
---|
413 |
|
---|
414 |
|
---|
415 | Bstr &Bstr::append(const char *pszThat, size_t cchMax)
|
---|
416 | {
|
---|
417 | return appendWorkerUtf8(pszThat, RTStrNLen(pszThat, cchMax));
|
---|
418 | }
|
---|
419 |
|
---|
420 |
|
---|
421 | HRESULT Bstr::appendNoThrow(const char *pszThat, size_t cchMax) RT_NOEXCEPT
|
---|
422 | {
|
---|
423 | return appendWorkerUtf8NoThrow(pszThat, RTStrNLen(pszThat, cchMax));
|
---|
424 | }
|
---|
425 |
|
---|
426 |
|
---|
427 | Bstr &Bstr::append(char ch)
|
---|
428 | {
|
---|
429 | AssertMsg(ch > 0 && ch < 127, ("%#x\n", ch));
|
---|
430 | return appendWorkerUtf8(&ch, 1);
|
---|
431 | }
|
---|
432 |
|
---|
433 |
|
---|
434 | HRESULT Bstr::appendNoThrow(char ch) RT_NOEXCEPT
|
---|
435 | {
|
---|
436 | AssertMsg(ch > 0 && ch < 127, ("%#x\n", ch));
|
---|
437 | return appendWorkerUtf8NoThrow(&ch, 1);
|
---|
438 | }
|
---|
439 |
|
---|
440 |
|
---|
441 | Bstr &Bstr::appendCodePoint(RTUNICP uc)
|
---|
442 | {
|
---|
443 | RTUTF16 wszTmp[3];
|
---|
444 | PRTUTF16 pwszEnd = RTUtf16PutCp(wszTmp, uc);
|
---|
445 | *pwszEnd = '\0';
|
---|
446 | return appendWorkerUtf16(&wszTmp[0], pwszEnd - &wszTmp[0]);
|
---|
447 | }
|
---|
448 |
|
---|
449 |
|
---|
450 | HRESULT Bstr::appendCodePointNoThrow(RTUNICP uc) RT_NOEXCEPT
|
---|
451 | {
|
---|
452 | RTUTF16 wszTmp[3];
|
---|
453 | PRTUTF16 pwszEnd = RTUtf16PutCp(wszTmp, uc);
|
---|
454 | *pwszEnd = '\0';
|
---|
455 | return appendWorkerUtf16NoThrow(&wszTmp[0], pwszEnd - &wszTmp[0]);
|
---|
456 | }
|
---|
457 |
|
---|
458 |
|
---|
459 | Bstr &Bstr::appendWorkerUtf16(PCRTUTF16 pwszSrc, size_t cwcSrc)
|
---|
460 | {
|
---|
461 | size_t cwcOld = length();
|
---|
462 | size_t cwcTotal = cwcOld + cwcSrc;
|
---|
463 | reserve(cwcTotal, true /*fForce*/);
|
---|
464 | if (cwcSrc)
|
---|
465 | memcpy(&m_bstr[cwcOld], pwszSrc, cwcSrc * sizeof(RTUTF16));
|
---|
466 | m_bstr[cwcTotal] = '\0';
|
---|
467 | return *this;
|
---|
468 | }
|
---|
469 |
|
---|
470 |
|
---|
471 | HRESULT Bstr::appendWorkerUtf16NoThrow(PCRTUTF16 pwszSrc, size_t cwcSrc) RT_NOEXCEPT
|
---|
472 | {
|
---|
473 | size_t cwcOld = length();
|
---|
474 | size_t cwcTotal = cwcOld + cwcSrc;
|
---|
475 | HRESULT hrc = reserveNoThrow(cwcTotal, true /*fForce*/);
|
---|
476 | if (hrc == S_OK)
|
---|
477 | {
|
---|
478 | if (cwcSrc)
|
---|
479 | memcpy(&m_bstr[cwcOld], pwszSrc, cwcSrc * sizeof(RTUTF16));
|
---|
480 | m_bstr[cwcTotal] = '\0';
|
---|
481 | }
|
---|
482 | return hrc;
|
---|
483 | }
|
---|
484 |
|
---|
485 |
|
---|
486 | Bstr &Bstr::appendWorkerUtf8(const char *pszSrc, size_t cchSrc)
|
---|
487 | {
|
---|
488 | size_t cwcSrc;
|
---|
489 | int rc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
|
---|
490 | AssertRCStmt(rc, throw std::bad_alloc());
|
---|
491 |
|
---|
492 | size_t cwcOld = length();
|
---|
493 | size_t cwcTotal = cwcOld + cwcSrc;
|
---|
494 | reserve(cwcTotal, true /*fForce*/);
|
---|
495 | if (cwcSrc)
|
---|
496 | {
|
---|
497 | PRTUTF16 pwszDst = &m_bstr[cwcOld];
|
---|
498 | rc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
|
---|
499 | AssertRCStmt(rc, throw std::bad_alloc());
|
---|
500 | }
|
---|
501 | m_bstr[cwcTotal] = '\0';
|
---|
502 | return *this;
|
---|
503 | }
|
---|
504 |
|
---|
505 |
|
---|
506 | HRESULT Bstr::appendWorkerUtf8NoThrow(const char *pszSrc, size_t cchSrc) RT_NOEXCEPT
|
---|
507 | {
|
---|
508 | size_t cwcSrc;
|
---|
509 | int rc = RTStrCalcUtf16LenEx(pszSrc, cchSrc, &cwcSrc);
|
---|
510 | AssertRCStmt(rc, E_INVALIDARG);
|
---|
511 |
|
---|
512 | size_t cwcOld = length();
|
---|
513 | size_t cwcTotal = cwcOld + cwcSrc;
|
---|
514 | HRESULT hrc = reserveNoThrow(cwcTotal, true /*fForce*/);
|
---|
515 | AssertReturn(hrc == S_OK, hrc);
|
---|
516 | if (cwcSrc)
|
---|
517 | {
|
---|
518 | PRTUTF16 pwszDst = &m_bstr[cwcOld];
|
---|
519 | rc = RTStrToUtf16Ex(pszSrc, cchSrc, &pwszDst, cwcSrc + 1, NULL);
|
---|
520 | AssertRCStmt(rc, E_INVALIDARG);
|
---|
521 | }
|
---|
522 | m_bstr[cwcTotal] = '\0';
|
---|
523 | return S_OK;
|
---|
524 | }
|
---|
525 |
|
---|
526 |
|
---|
527 | Bstr &Bstr::appendPrintf(const char *pszFormat, ...)
|
---|
528 | {
|
---|
529 | va_list va;
|
---|
530 | va_start(va, pszFormat);
|
---|
531 | HRESULT hrc = appendPrintfVNoThrow(pszFormat, va);
|
---|
532 | va_end(va);
|
---|
533 | if (hrc != S_OK)
|
---|
534 | throw std::bad_alloc();
|
---|
535 | return *this;
|
---|
536 | }
|
---|
537 |
|
---|
538 |
|
---|
539 | HRESULT Bstr::appendPrintfNoThrow(const char *pszFormat, ...) RT_NOEXCEPT
|
---|
540 | {
|
---|
541 | va_list va;
|
---|
542 | va_start(va, pszFormat);
|
---|
543 | HRESULT hrc = appendPrintfVNoThrow(pszFormat, va);
|
---|
544 | va_end(va);
|
---|
545 | return hrc;
|
---|
546 | }
|
---|
547 |
|
---|
548 |
|
---|
549 | Bstr &Bstr::appendPrintfV(const char *pszFormat, va_list va)
|
---|
550 | {
|
---|
551 | HRESULT hrc = appendPrintfVNoThrow(pszFormat, va);
|
---|
552 | if (hrc != S_OK)
|
---|
553 | throw std::bad_alloc();
|
---|
554 | return *this;
|
---|
555 | }
|
---|
556 |
|
---|
557 |
|
---|
558 | HRESULT Bstr::appendPrintfVNoThrow(const char *pszFormat, va_list va) RT_NOEXCEPT
|
---|
559 | {
|
---|
560 | size_t const cwcOld = length();
|
---|
561 | BSTRNOTHROW Args = { this, cwcOld, cwcOld, S_OK };
|
---|
562 |
|
---|
563 | RTStrFormatV(printfOutputCallbackNoThrow, &Args, NULL, NULL, pszFormat, va);
|
---|
564 | if (Args.hrc == S_OK)
|
---|
565 | {
|
---|
566 | Args.hrc = joltNoThrow(Args.offDst);
|
---|
567 | if (Args.hrc == S_OK)
|
---|
568 | return S_OK;
|
---|
569 | }
|
---|
570 |
|
---|
571 | if (m_bstr)
|
---|
572 | m_bstr[cwcOld] = '\0';
|
---|
573 | return Args.hrc;
|
---|
574 | }
|
---|
575 |
|
---|
576 |
|
---|
577 | Bstr &Bstr::erase(size_t offStart /*= 0*/, size_t cwcLength /*= RTSTR_MAX*/) RT_NOEXCEPT
|
---|
578 | {
|
---|
579 | size_t cwc = length();
|
---|
580 | if (offStart < cwc)
|
---|
581 | {
|
---|
582 | if (cwcLength >= cwc - offStart)
|
---|
583 | {
|
---|
584 | if (!offStart)
|
---|
585 | cleanup();
|
---|
586 | else
|
---|
587 | {
|
---|
588 | /* Trail removal, nothing to move. */
|
---|
589 | m_bstr[offStart] = '\0';
|
---|
590 | joltNoThrow(offStart); /* not entirely optimal... */
|
---|
591 | }
|
---|
592 | }
|
---|
593 | else if (cwcLength > 0)
|
---|
594 | {
|
---|
595 | /* Pull up the tail to offStart. */
|
---|
596 | size_t cwcAfter = cwc - offStart - cwcLength;
|
---|
597 | memmove(&m_bstr[offStart], &m_bstr[offStart + cwcLength], cwcAfter * sizeof(*m_bstr));
|
---|
598 | cwc -= cwcLength;
|
---|
599 | m_bstr[cwc] = '\0';
|
---|
600 | joltNoThrow(cwc); /* not entirely optimal... */
|
---|
601 | }
|
---|
602 | }
|
---|
603 | return *this;
|
---|
604 | }
|
---|
605 |
|
---|
606 |
|
---|
607 | void Bstr::cleanup()
|
---|
608 | {
|
---|
609 | if (m_bstr)
|
---|
610 | {
|
---|
611 | ::SysFreeString(m_bstr);
|
---|
612 | m_bstr = NULL;
|
---|
613 | }
|
---|
614 | }
|
---|
615 |
|
---|
616 |
|
---|
617 | void Bstr::copyFrom(const OLECHAR *a_bstrSrc)
|
---|
618 | {
|
---|
619 | if (a_bstrSrc && *a_bstrSrc)
|
---|
620 | {
|
---|
621 | m_bstr = ::SysAllocString(a_bstrSrc);
|
---|
622 | if (!m_bstr)
|
---|
623 | throw std::bad_alloc();
|
---|
624 | }
|
---|
625 | else
|
---|
626 | m_bstr = NULL;
|
---|
627 | }
|
---|
628 |
|
---|
629 |
|
---|
630 | void Bstr::cleanupAndCopyFrom(const OLECHAR *a_bstrSrc)
|
---|
631 | {
|
---|
632 | cleanup();
|
---|
633 | copyFrom(a_bstrSrc);
|
---|
634 | }
|
---|
635 |
|
---|
636 |
|
---|
637 |
|
---|
638 | /*********************************************************************************************************************************
|
---|
639 | * Utf8Str Implementation *
|
---|
640 | *********************************************************************************************************************************/
|
---|
641 |
|
---|
642 | /* static */
|
---|
643 | const Utf8Str Utf8Str::Empty; /* default ctor is OK */
|
---|
644 |
|
---|
645 | #if defined(VBOX_WITH_XPCOM)
|
---|
646 | void Utf8Str::cloneTo(char **pstr) const
|
---|
647 | {
|
---|
648 | size_t cb = length() + 1;
|
---|
649 | *pstr = (char *)nsMemory::Alloc(cb);
|
---|
650 | if (RT_LIKELY(*pstr))
|
---|
651 | memcpy(*pstr, c_str(), cb);
|
---|
652 | else
|
---|
653 | throw std::bad_alloc();
|
---|
654 | }
|
---|
655 |
|
---|
656 | HRESULT Utf8Str::cloneToEx(char **pstr) const
|
---|
657 | {
|
---|
658 | size_t cb = length() + 1;
|
---|
659 | *pstr = (char *)nsMemory::Alloc(cb);
|
---|
660 | if (RT_LIKELY(*pstr))
|
---|
661 | {
|
---|
662 | memcpy(*pstr, c_str(), cb);
|
---|
663 | return S_OK;
|
---|
664 | }
|
---|
665 | return E_OUTOFMEMORY;
|
---|
666 | }
|
---|
667 | #endif
|
---|
668 |
|
---|
669 | Utf8Str& Utf8Str::stripTrailingSlash()
|
---|
670 | {
|
---|
671 | if (length())
|
---|
672 | {
|
---|
673 | ::RTPathStripTrailingSlash(m_psz);
|
---|
674 | jolt();
|
---|
675 | }
|
---|
676 | return *this;
|
---|
677 | }
|
---|
678 |
|
---|
679 | Utf8Str& Utf8Str::stripFilename()
|
---|
680 | {
|
---|
681 | if (length())
|
---|
682 | {
|
---|
683 | RTPathStripFilename(m_psz);
|
---|
684 | jolt();
|
---|
685 | }
|
---|
686 | return *this;
|
---|
687 | }
|
---|
688 |
|
---|
689 | Utf8Str& Utf8Str::stripPath()
|
---|
690 | {
|
---|
691 | if (length())
|
---|
692 | {
|
---|
693 | char *pszName = ::RTPathFilename(m_psz);
|
---|
694 | if (pszName)
|
---|
695 | {
|
---|
696 | size_t cchName = length() - (pszName - m_psz);
|
---|
697 | memmove(m_psz, pszName, cchName + 1);
|
---|
698 | jolt();
|
---|
699 | }
|
---|
700 | else
|
---|
701 | cleanup();
|
---|
702 | }
|
---|
703 | return *this;
|
---|
704 | }
|
---|
705 |
|
---|
706 | Utf8Str& Utf8Str::stripSuffix()
|
---|
707 | {
|
---|
708 | if (length())
|
---|
709 | {
|
---|
710 | RTPathStripSuffix(m_psz);
|
---|
711 | jolt();
|
---|
712 | }
|
---|
713 | return *this;
|
---|
714 | }
|
---|
715 |
|
---|
716 | size_t Utf8Str::parseKeyValue(Utf8Str &a_rKey, Utf8Str &a_rValue, size_t a_offStart /* = 0*/,
|
---|
717 | const Utf8Str &a_rPairSeparator /*= ","*/, const Utf8Str &a_rKeyValueSeparator /*= "="*/) const
|
---|
718 | {
|
---|
719 | /* Find the end of the next pair, skipping empty pairs.
|
---|
720 | Note! The skipping allows us to pass the return value of a parseKeyValue()
|
---|
721 | call as offStart to the next call. */
|
---|
722 | size_t offEnd;
|
---|
723 | while ( a_offStart == (offEnd = find(&a_rPairSeparator, a_offStart))
|
---|
724 | && offEnd != npos)
|
---|
725 | a_offStart++;
|
---|
726 |
|
---|
727 | /* Look for a key/value separator before the end of the pair.
|
---|
728 | ASSUMES npos value returned by find when the substring is not found is
|
---|
729 | really high. */
|
---|
730 | size_t offKeyValueSep = find(&a_rKeyValueSeparator, a_offStart);
|
---|
731 | if (offKeyValueSep < offEnd)
|
---|
732 | {
|
---|
733 | a_rKey = substr(a_offStart, offKeyValueSep - a_offStart);
|
---|
734 | if (offEnd == npos)
|
---|
735 | offEnd = m_cch; /* No confusing npos when returning strings. */
|
---|
736 | a_rValue = substr(offKeyValueSep + 1, offEnd - offKeyValueSep - 1);
|
---|
737 | }
|
---|
738 | else
|
---|
739 | {
|
---|
740 | a_rKey.setNull();
|
---|
741 | a_rValue.setNull();
|
---|
742 | }
|
---|
743 |
|
---|
744 | return offEnd;
|
---|
745 | }
|
---|
746 |
|
---|
747 | /**
|
---|
748 | * Internal function used in Utf8Str copy constructors and assignment when
|
---|
749 | * copying from a UTF-16 string.
|
---|
750 | *
|
---|
751 | * As with the RTCString::copyFrom() variants, this unconditionally sets the
|
---|
752 | * members to a copy of the given other strings and makes no assumptions about
|
---|
753 | * previous contents. This can therefore be used both in copy constructors,
|
---|
754 | * when member variables have no defined value, and in assignments after having
|
---|
755 | * called cleanup().
|
---|
756 | *
|
---|
757 | * This variant converts from a UTF-16 string, most probably from
|
---|
758 | * a Bstr assignment.
|
---|
759 | *
|
---|
760 | * @param a_pbstr The source string. The caller guarantees that this
|
---|
761 | * is valid UTF-16.
|
---|
762 | * @param a_cwcMax The number of characters to be copied. If set to RTSTR_MAX,
|
---|
763 | * the entire string will be copied.
|
---|
764 | *
|
---|
765 | * @sa RTCString::copyFromN
|
---|
766 | */
|
---|
767 | void Utf8Str::copyFrom(CBSTR a_pbstr, size_t a_cwcMax)
|
---|
768 | {
|
---|
769 | if (a_pbstr && *a_pbstr)
|
---|
770 | {
|
---|
771 | int vrc = RTUtf16ToUtf8Ex((PCRTUTF16)a_pbstr,
|
---|
772 | a_cwcMax, // size_t cwcString: translate entire string
|
---|
773 | &m_psz, // char **ppsz: output buffer
|
---|
774 | 0, // size_t cch: if 0, func allocates buffer in *ppsz
|
---|
775 | &m_cch); // size_t *pcch: receives the size of the output string, excluding the terminator.
|
---|
776 | if (RT_SUCCESS(vrc))
|
---|
777 | m_cbAllocated = m_cch + 1;
|
---|
778 | else
|
---|
779 | {
|
---|
780 | if ( vrc != VERR_NO_STR_MEMORY
|
---|
781 | && vrc != VERR_NO_MEMORY)
|
---|
782 | {
|
---|
783 | /* ASSUME: input is valid Utf-16. Fake out of memory error. */
|
---|
784 | AssertLogRelMsgFailed(("%Rrc %.*Rhxs\n", vrc, RTUtf16Len(a_pbstr) * sizeof(RTUTF16), a_pbstr));
|
---|
785 | }
|
---|
786 |
|
---|
787 | m_cch = 0;
|
---|
788 | m_cbAllocated = 0;
|
---|
789 | m_psz = NULL;
|
---|
790 |
|
---|
791 | throw std::bad_alloc();
|
---|
792 | }
|
---|
793 | }
|
---|
794 | else
|
---|
795 | {
|
---|
796 | m_cch = 0;
|
---|
797 | m_cbAllocated = 0;
|
---|
798 | m_psz = NULL;
|
---|
799 | }
|
---|
800 | }
|
---|
801 |
|
---|
802 | /**
|
---|
803 | * A variant of Utf8Str::copyFrom that does not throw any exceptions but returns
|
---|
804 | * E_OUTOFMEMORY instead.
|
---|
805 | *
|
---|
806 | * @param a_pbstr The source string.
|
---|
807 | * @returns S_OK or E_OUTOFMEMORY.
|
---|
808 | */
|
---|
809 | HRESULT Utf8Str::copyFromEx(CBSTR a_pbstr)
|
---|
810 | {
|
---|
811 | if (a_pbstr && *a_pbstr)
|
---|
812 | {
|
---|
813 | int vrc = RTUtf16ToUtf8Ex((PCRTUTF16)a_pbstr,
|
---|
814 | RTSTR_MAX, // size_t cwcString: translate entire string
|
---|
815 | &m_psz, // char **ppsz: output buffer
|
---|
816 | 0, // size_t cch: if 0, func allocates buffer in *ppsz
|
---|
817 | &m_cch); // size_t *pcch: receives the size of the output string, excluding the terminator.
|
---|
818 | if (RT_SUCCESS(vrc))
|
---|
819 | m_cbAllocated = m_cch + 1;
|
---|
820 | else
|
---|
821 | {
|
---|
822 | if ( vrc != VERR_NO_STR_MEMORY
|
---|
823 | && vrc != VERR_NO_MEMORY)
|
---|
824 | {
|
---|
825 | /* ASSUME: input is valid Utf-16. Fake out of memory error. */
|
---|
826 | AssertLogRelMsgFailed(("%Rrc %.*Rhxs\n", vrc, RTUtf16Len(a_pbstr) * sizeof(RTUTF16), a_pbstr));
|
---|
827 | }
|
---|
828 |
|
---|
829 | m_cch = 0;
|
---|
830 | m_cbAllocated = 0;
|
---|
831 | m_psz = NULL;
|
---|
832 |
|
---|
833 | return E_OUTOFMEMORY;
|
---|
834 | }
|
---|
835 | }
|
---|
836 | else
|
---|
837 | {
|
---|
838 | m_cch = 0;
|
---|
839 | m_cbAllocated = 0;
|
---|
840 | m_psz = NULL;
|
---|
841 | }
|
---|
842 | return S_OK;
|
---|
843 | }
|
---|
844 |
|
---|
845 |
|
---|
846 | /**
|
---|
847 | * A variant of Utf8Str::copyFromN that does not throw any exceptions but
|
---|
848 | * returns E_OUTOFMEMORY instead.
|
---|
849 | *
|
---|
850 | * @param a_pcszSrc The source string.
|
---|
851 | * @param a_offSrc Start offset to copy from.
|
---|
852 | * @param a_cchSrc How much to copy
|
---|
853 | * @returns S_OK or E_OUTOFMEMORY.
|
---|
854 | *
|
---|
855 | * @remarks This calls cleanup() first, so the caller doesn't have to. (Saves
|
---|
856 | * code space.)
|
---|
857 | */
|
---|
858 | HRESULT Utf8Str::copyFromExNComRC(const char *a_pcszSrc, size_t a_offSrc, size_t a_cchSrc)
|
---|
859 | {
|
---|
860 | Assert(!a_cchSrc || !m_psz || (uintptr_t)&a_pcszSrc[a_offSrc] - (uintptr_t)m_psz >= (uintptr_t)m_cbAllocated);
|
---|
861 | cleanup();
|
---|
862 | if (a_cchSrc)
|
---|
863 | {
|
---|
864 | m_psz = RTStrAlloc(a_cchSrc + 1);
|
---|
865 | if (RT_LIKELY(m_psz))
|
---|
866 | {
|
---|
867 | m_cch = a_cchSrc;
|
---|
868 | m_cbAllocated = a_cchSrc + 1;
|
---|
869 | memcpy(m_psz, a_pcszSrc + a_offSrc, a_cchSrc);
|
---|
870 | m_psz[a_cchSrc] = '\0';
|
---|
871 | }
|
---|
872 | else
|
---|
873 | {
|
---|
874 | m_cch = 0;
|
---|
875 | m_cbAllocated = 0;
|
---|
876 | return E_OUTOFMEMORY;
|
---|
877 | }
|
---|
878 | }
|
---|
879 | else
|
---|
880 | {
|
---|
881 | m_cch = 0;
|
---|
882 | m_cbAllocated = 0;
|
---|
883 | m_psz = NULL;
|
---|
884 | }
|
---|
885 | return S_OK;
|
---|
886 | }
|
---|
887 |
|
---|
888 | } /* namespace com */
|
---|