42a7ad72a6182225c27c7fcc878b08a1e072ebe5
[pdfium.git] / core / src / fxcrt / fx_basic_wstring.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6
7 #include "../../include/fxcrt/fx_basic.h"
8 #include "../../../third_party/base/numerics/safe_math.h"
9
10 static CFX_StringDataW* FX_AllocStringW(int nLen)
11 {
12     // TODO(palmer): |nLen| should really be declared as |size_t|, or
13     // at least unsigned.
14     if (nLen == 0 || nLen < 0) {
15         return NULL;
16     }
17
18     int overhead = 3 * sizeof(long) + sizeof(FX_WCHAR);  // +WCHAR is for NUL.
19     pdfium::base::CheckedNumeric<int> iSize = nLen;
20     iSize *= sizeof(FX_WCHAR);
21     iSize += overhead;
22
23     // Now round to an 8-byte boundary. We'd expect that this is the minimum
24     // granularity of any of the underlying allocators, so there may be cases
25     // where we can save a re-alloc when adding a few characters to a string
26     // by using this otherwise wasted space.
27     iSize += 7;
28     int totalSize = iSize.ValueOrDie() & ~7;
29     int usableLen = (totalSize - overhead) / sizeof(FX_WCHAR);
30     FXSYS_assert(usableLen >= nLen);
31
32     CFX_StringDataW* pData = (CFX_StringDataW*)FX_Alloc(FX_BYTE, iSize.ValueOrDie());
33     if (!pData) {
34         return NULL;
35     }
36
37     pData->m_nAllocLength = usableLen;
38     pData->m_nDataLength = nLen;
39     pData->m_nRefs = 1;
40     pData->m_String[nLen] = 0;
41     return pData;
42 }
43 static void FX_ReleaseStringW(CFX_StringDataW* pData)
44 {
45     if (pData == NULL) {
46         return;
47     }
48     pData->m_nRefs --;
49     if (pData->m_nRefs <= 0) {
50         FX_Free(pData);
51     }
52 }
53 CFX_WideString::~CFX_WideString()
54 {
55     if (m_pData == NULL) {
56         return;
57     }
58     m_pData->m_nRefs --;
59     if (m_pData->m_nRefs < 1) {
60         FX_Free(m_pData);
61     }
62 }
63 void CFX_WideString::InitStr(FX_LPCWSTR lpsz, FX_STRSIZE nLen)
64 {
65     if (nLen < 0) {
66         nLen = lpsz ? (FX_STRSIZE)FXSYS_wcslen(lpsz) : 0;
67     }
68     if (nLen) {
69         m_pData = FX_AllocStringW(nLen);
70         if (!m_pData) {
71             return;
72         }
73         FXSYS_memcpy32(m_pData->m_String, lpsz, nLen * sizeof(FX_WCHAR));
74     } else {
75         m_pData = NULL;
76     }
77 }
78 CFX_WideString::CFX_WideString(const CFX_WideString& stringSrc)
79 {
80     if (stringSrc.m_pData == NULL) {
81         m_pData = NULL;
82         return;
83     }
84     if (stringSrc.m_pData->m_nRefs >= 0) {
85         m_pData = stringSrc.m_pData;
86         m_pData->m_nRefs ++;
87     } else {
88         m_pData = NULL;
89         *this = stringSrc;
90     }
91 }
92 CFX_WideString::CFX_WideString(FX_WCHAR ch)
93 {
94     m_pData = FX_AllocStringW(1);
95     if (m_pData) {
96         m_pData->m_String[0] = ch;
97     }
98 }
99 CFX_WideString::CFX_WideString(const CFX_WideStringC& str)
100 {
101     if (str.IsEmpty()) {
102         m_pData = NULL;
103         return;
104     }
105     m_pData = FX_AllocStringW(str.GetLength());
106     if (m_pData) {
107         FXSYS_memcpy32(m_pData->m_String, str.GetPtr(), str.GetLength()*sizeof(FX_WCHAR));
108     }
109 }
110 CFX_WideString::CFX_WideString(const CFX_WideStringC& str1, const CFX_WideStringC& str2)
111 {
112     m_pData = NULL;
113     int nNewLen = str1.GetLength() + str2.GetLength();
114     if (nNewLen == 0) {
115         return;
116     }
117     m_pData = FX_AllocStringW(nNewLen);
118     if (m_pData) {
119         FXSYS_memcpy32(m_pData->m_String, str1.GetPtr(), str1.GetLength()*sizeof(FX_WCHAR));
120         FXSYS_memcpy32(m_pData->m_String + str1.GetLength(), str2.GetPtr(), str2.GetLength()*sizeof(FX_WCHAR));
121     }
122 }
123 void CFX_WideString::ReleaseBuffer(FX_STRSIZE nNewLength)
124 {
125     if (m_pData == NULL) {
126         return;
127     }
128     CopyBeforeWrite();
129     if (nNewLength == -1) {
130         nNewLength = m_pData ? (FX_STRSIZE)FXSYS_wcslen(m_pData->m_String) : 0;
131     }
132     if (nNewLength == 0) {
133         Empty();
134         return;
135     }
136     FXSYS_assert(nNewLength <= m_pData->m_nAllocLength);
137     m_pData->m_nDataLength = nNewLength;
138     m_pData->m_String[nNewLength] = 0;
139 }
140 const CFX_WideString& CFX_WideString::operator=(FX_LPCWSTR lpsz)
141 {
142     if (lpsz == NULL || lpsz[0] == 0) {
143         Empty();
144     } else {
145         AssignCopy((FX_STRSIZE)FXSYS_wcslen(lpsz), lpsz);
146     }
147     return *this;
148 }
149 const CFX_WideString& CFX_WideString::operator=(const CFX_WideStringC& stringSrc)
150 {
151     if (stringSrc.IsEmpty()) {
152         Empty();
153     } else {
154         AssignCopy(stringSrc.GetLength(), stringSrc.GetPtr());
155     }
156     return *this;
157 }
158 const CFX_WideString& CFX_WideString::operator=(const CFX_WideString& stringSrc)
159 {
160     if (m_pData == stringSrc.m_pData) {
161         return *this;
162     }
163     if (stringSrc.IsEmpty()) {
164         Empty();
165     } else if ((m_pData && m_pData->m_nRefs < 0) ||
166                (stringSrc.m_pData && stringSrc.m_pData->m_nRefs < 0)) {
167         AssignCopy(stringSrc.m_pData->m_nDataLength, stringSrc.m_pData->m_String);
168     } else {
169         Empty();
170         m_pData = stringSrc.m_pData;
171         if (m_pData) {
172             m_pData->m_nRefs ++;
173         }
174     }
175     return *this;
176 }
177 const CFX_WideString& CFX_WideString::operator+=(FX_WCHAR ch)
178 {
179     ConcatInPlace(1, &ch);
180     return *this;
181 }
182 const CFX_WideString& CFX_WideString::operator+=(FX_LPCWSTR lpsz)
183 {
184     if (lpsz) {
185         ConcatInPlace((FX_STRSIZE)FXSYS_wcslen(lpsz), lpsz);
186     }
187     return *this;
188 }
189 const CFX_WideString& CFX_WideString::operator+=(const CFX_WideString& string)
190 {
191     if (string.m_pData == NULL) {
192         return *this;
193     }
194     ConcatInPlace(string.m_pData->m_nDataLength, string.m_pData->m_String);
195     return *this;
196 }
197 const CFX_WideString& CFX_WideString::operator+=(const CFX_WideStringC& string)
198 {
199     if (string.IsEmpty()) {
200         return *this;
201     }
202     ConcatInPlace(string.GetLength(), string.GetPtr());
203     return *this;
204 }
205 bool operator==(const CFX_WideString& s1, FX_LPCWSTR s2)
206 {
207     return s1.Equal(s2);
208 }
209 bool operator==(FX_LPCWSTR s1, const CFX_WideString& s2)
210 {
211     return s2.Equal(s1);
212 }
213 bool operator==(const CFX_WideString& s1, const CFX_WideString& s2)
214 {
215     return s1.Equal(s2);
216 }
217 bool operator==(const CFX_WideString& s1, const CFX_WideStringC& s2)
218 {
219     return s1.Equal(s2);
220 }
221 bool operator==(const CFX_WideStringC& s1, const CFX_WideString& s2)
222 {
223     return s2.Equal(s1);
224 }
225 bool operator != (const CFX_WideString& s1, FX_LPCWSTR s2)
226 {
227     return !s1.Equal(s2);
228 }
229 bool operator!=(const CFX_WideString& s1, const CFX_WideString& s2)
230 {
231     return !s1.Equal(s2);
232 }
233 bool operator!=(const CFX_WideString& s1, const CFX_WideStringC& s2)
234 {
235     return !s1.Equal(s2);
236 }
237 bool operator!=(const CFX_WideStringC& s1, const CFX_WideString& s2)
238 {
239     return !s2.Equal(s1);
240 }
241 bool CFX_WideString::Equal(const CFX_WideStringC& str) const
242 {
243     if (m_pData == NULL) {
244         return str.IsEmpty();
245     }
246     return str.GetLength() == m_pData->m_nDataLength &&
247            FXSYS_memcmp32(str.GetPtr(), m_pData->m_String, m_pData->m_nDataLength * sizeof(FX_WCHAR)) == 0;
248 }
249 void CFX_WideString::Empty()
250 {
251     if (m_pData == NULL) {
252         return;
253     }
254     if (m_pData->m_nRefs > 1) {
255         m_pData->m_nRefs --;
256     } else {
257         FX_Free(m_pData);
258     }
259     m_pData = NULL;
260 }
261 void CFX_WideString::ConcatInPlace(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData)
262 {
263     if (nSrcLen == 0 || lpszSrcData == NULL) {
264         return;
265     }
266     if (m_pData == NULL) {
267         m_pData = FX_AllocStringW(nSrcLen);
268         if (m_pData) {
269             FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
270         }
271         return;
272     }
273     if (m_pData->m_nRefs > 1 || m_pData->m_nDataLength + nSrcLen > m_pData->m_nAllocLength) {
274         CFX_StringDataW* pOldData = m_pData;
275         ConcatCopy(m_pData->m_nDataLength, m_pData->m_String, nSrcLen, lpszSrcData);
276         FX_ReleaseStringW(pOldData);
277     } else {
278         FXSYS_memcpy32(m_pData->m_String + m_pData->m_nDataLength, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
279         m_pData->m_nDataLength += nSrcLen;
280         m_pData->m_String[m_pData->m_nDataLength] = 0;
281     }
282 }
283 void CFX_WideString::ConcatCopy(FX_STRSIZE nSrc1Len, FX_LPCWSTR lpszSrc1Data,
284                                 FX_STRSIZE nSrc2Len, FX_LPCWSTR lpszSrc2Data)
285 {
286     FX_STRSIZE nNewLen = nSrc1Len + nSrc2Len;
287     if (nNewLen == 0) {
288         return;
289     }
290     m_pData = FX_AllocStringW(nNewLen);
291     if (m_pData) {
292         FXSYS_memcpy32(m_pData->m_String, lpszSrc1Data, nSrc1Len * sizeof(FX_WCHAR));
293         FXSYS_memcpy32(m_pData->m_String + nSrc1Len, lpszSrc2Data, nSrc2Len * sizeof(FX_WCHAR));
294     }
295 }
296 void CFX_WideString::CopyBeforeWrite()
297 {
298     if (m_pData == NULL || m_pData->m_nRefs <= 1) {
299         return;
300     }
301     CFX_StringDataW* pData = m_pData;
302     m_pData->m_nRefs --;
303     FX_STRSIZE nDataLength = pData->m_nDataLength;
304     m_pData = FX_AllocStringW(nDataLength);
305     if (m_pData != NULL) {
306         FXSYS_memcpy32(m_pData->m_String, pData->m_String, (nDataLength + 1) * sizeof(FX_WCHAR));
307     }
308 }
309 void CFX_WideString::AllocBeforeWrite(FX_STRSIZE nLen)
310 {
311     if (m_pData && m_pData->m_nRefs <= 1 && m_pData->m_nAllocLength >= nLen) {
312         return;
313     }
314     Empty();
315     m_pData = FX_AllocStringW(nLen);
316 }
317 void CFX_WideString::AssignCopy(FX_STRSIZE nSrcLen, FX_LPCWSTR lpszSrcData)
318 {
319     AllocBeforeWrite(nSrcLen);
320     FXSYS_memcpy32(m_pData->m_String, lpszSrcData, nSrcLen * sizeof(FX_WCHAR));
321     m_pData->m_nDataLength = nSrcLen;
322     m_pData->m_String[nSrcLen] = 0;
323 }
324 int CFX_WideString::Compare(FX_LPCWSTR lpsz) const
325 {
326     if (m_pData == NULL) {
327         return (lpsz == NULL || lpsz[0] == 0) ? 0 : -1;
328     }
329     return FXSYS_wcscmp(m_pData->m_String, lpsz);
330 }
331 CFX_ByteString CFX_WideString::UTF8Encode() const
332 {
333     return FX_UTF8Encode(*this);
334 }
335 CFX_ByteString CFX_WideString::UTF16LE_Encode() const
336 {
337     if (m_pData == NULL) {
338         return CFX_ByteString(FX_BSTRC("\0\0"));
339     }
340     int len = m_pData->m_nDataLength;
341     CFX_ByteString result;
342     FX_LPSTR buffer = result.GetBuffer(len * 2 + 2);
343     for (int i = 0; i < len; i ++) {
344         buffer[i * 2] = m_pData->m_String[i] & 0xff;
345         buffer[i * 2 + 1] = m_pData->m_String[i] >> 8;
346     }
347     buffer[len * 2] = 0;
348     buffer[len * 2 + 1] = 0;
349     result.ReleaseBuffer(len * 2 + 2);
350     return result;
351 }
352 void CFX_WideString::ConvertFrom(const CFX_ByteString& str, CFX_CharMap* pCharMap)
353 {
354     if (pCharMap == NULL) {
355         pCharMap = CFX_CharMap::GetDefaultMapper();
356     }
357     *this = pCharMap->m_GetWideString(pCharMap, str);
358 }
359 void CFX_WideString::Reserve(FX_STRSIZE len)
360 {
361     GetBuffer(len);
362     ReleaseBuffer(GetLength());
363 }
364 FX_LPWSTR CFX_WideString::GetBuffer(FX_STRSIZE nMinBufLength)
365 {
366     if (m_pData == NULL && nMinBufLength == 0) {
367         return NULL;
368     }
369     if (m_pData && m_pData->m_nRefs <= 1 && m_pData->m_nAllocLength >= nMinBufLength) {
370         return m_pData->m_String;
371     }
372     if (m_pData == NULL) {
373         m_pData = FX_AllocStringW(nMinBufLength);
374         if (!m_pData) {
375             return NULL;
376         }
377         m_pData->m_nDataLength = 0;
378         m_pData->m_String[0] = 0;
379         return m_pData->m_String;
380     }
381     CFX_StringDataW* pOldData = m_pData;
382     FX_STRSIZE nOldLen = pOldData->m_nDataLength;
383     if (nMinBufLength < nOldLen) {
384         nMinBufLength = nOldLen;
385     }
386     m_pData = FX_AllocStringW(nMinBufLength);
387     if (!m_pData) {
388         return NULL;
389     }
390     FXSYS_memcpy32(m_pData->m_String, pOldData->m_String, (nOldLen + 1)*sizeof(FX_WCHAR));
391     m_pData->m_nDataLength = nOldLen;
392     pOldData->m_nRefs --;
393     if (pOldData->m_nRefs <= 0) {
394         FX_Free(pOldData);
395     }
396     return m_pData->m_String;
397 }
398 CFX_WideString CFX_WideString::FromLocal(const char* str, FX_STRSIZE len)
399 {
400     CFX_WideString result;
401     result.ConvertFrom(CFX_ByteString(str, len));
402     return result;
403 }
404 CFX_WideString CFX_WideString::FromUTF8(const char* str, FX_STRSIZE len)
405 {
406     if (!str || 0 == len) {
407         return CFX_WideString();
408     }
409
410     CFX_UTF8Decoder decoder;
411     for (FX_STRSIZE i = 0; i < len; i ++) {
412         decoder.Input(str[i]);
413     }
414     return decoder.GetResult();
415 }
416 CFX_WideString CFX_WideString::FromUTF16LE(const unsigned short* wstr, FX_STRSIZE wlen)
417 {
418     if (!wstr || 0 == wlen) {
419         return CFX_WideString();
420     }
421
422     CFX_WideString result;
423     FX_WCHAR* buf = result.GetBuffer(wlen);
424     for (int i = 0; i < wlen; i ++) {
425         buf[i] = wstr[i];
426     }
427     result.ReleaseBuffer(wlen);
428     return result;
429 }
430 FX_STRSIZE CFX_WideString::WStringLength(const unsigned short* str)
431 {
432     FX_STRSIZE len = 0;
433     if (str)
434         while (str[len]) len++;
435     return len;
436 }
437
438
439
440 void CFX_WideString::AllocCopy(CFX_WideString& dest, FX_STRSIZE nCopyLen, FX_STRSIZE nCopyIndex) const
441 {
442     // |FX_STRSIZE| is currently typedef'd as in |int|. TODO(palmer): It
443     // should be a |size_t|, or at least unsigned.
444     if (nCopyLen == 0 || nCopyLen < 0) {
445         return;
446     }
447     pdfium::base::CheckedNumeric<FX_STRSIZE> iSize = static_cast<FX_STRSIZE>(sizeof(FX_WCHAR));
448     iSize *= nCopyLen;
449     ASSERT(dest.m_pData == NULL);
450     dest.m_pData = FX_AllocStringW(nCopyLen);
451     if (dest.m_pData) {
452         FXSYS_memcpy32(dest.m_pData->m_String, m_pData->m_String + nCopyIndex, iSize.ValueOrDie());
453     }
454 }
455 CFX_WideString CFX_WideString::Left(FX_STRSIZE nCount) const
456 {
457     if (m_pData == NULL) {
458         return CFX_WideString();
459     }
460     if (nCount < 0) {
461         nCount = 0;
462     }
463     if (nCount >= m_pData->m_nDataLength) {
464         return *this;
465     }
466     CFX_WideString dest;
467     AllocCopy(dest, nCount, 0);
468     return dest;
469 }
470 CFX_WideString CFX_WideString::Mid(FX_STRSIZE nFirst) const
471 {
472     return Mid(nFirst, m_pData->m_nDataLength - nFirst);
473 }
474 CFX_WideString CFX_WideString::Mid(FX_STRSIZE nFirst, FX_STRSIZE nCount) const
475 {
476     if (m_pData == NULL) {
477         return CFX_WideString();
478     }
479     if (nFirst < 0) {
480         nFirst = 0;
481     }
482     if (nCount < 0) {
483         nCount = 0;
484     }
485     if (nFirst + nCount > m_pData->m_nDataLength) {
486         nCount = m_pData->m_nDataLength - nFirst;
487     }
488     if (nFirst > m_pData->m_nDataLength) {
489         nCount = 0;
490     }
491     if (nFirst == 0 && nFirst + nCount == m_pData->m_nDataLength) {
492         return *this;
493     }
494     CFX_WideString dest;
495     AllocCopy(dest, nCount, nFirst);
496     return dest;
497 }
498 CFX_WideString CFX_WideString::Right(FX_STRSIZE nCount) const
499 {
500     if (m_pData == NULL) {
501         return CFX_WideString();
502     }
503     if (nCount < 0) {
504         nCount = 0;
505     }
506     if (nCount >= m_pData->m_nDataLength) {
507         return *this;
508     }
509     CFX_WideString dest;
510     AllocCopy(dest, nCount, m_pData->m_nDataLength - nCount);
511     return dest;
512 }
513 int CFX_WideString::CompareNoCase(FX_LPCWSTR lpsz) const
514 {
515     if (m_pData == NULL) {
516         return (lpsz == NULL || lpsz[0] == 0) ? 0 : -1;
517     }
518     return FXSYS_wcsicmp(m_pData->m_String, lpsz);
519 }
520 int CFX_WideString::Compare(const CFX_WideString& str) const
521 {
522     if (m_pData == NULL) {
523         if (str.m_pData == NULL) {
524             return 0;
525         }
526         return -1;
527     } else if (str.m_pData == NULL) {
528         return 1;
529     }
530     int this_len = m_pData->m_nDataLength;
531     int that_len = str.m_pData->m_nDataLength;
532     int min_len = this_len < that_len ? this_len : that_len;
533     for (int i = 0; i < min_len; i ++) {
534         if (m_pData->m_String[i] < str.m_pData->m_String[i]) {
535             return -1;
536         } else if (m_pData->m_String[i] > str.m_pData->m_String[i]) {
537             return 1;
538         }
539     }
540     if (this_len < that_len) {
541         return -1;
542     } else if (this_len > that_len) {
543         return 1;
544     }
545     return 0;
546 }
547 void CFX_WideString::SetAt(FX_STRSIZE nIndex, FX_WCHAR ch)
548 {
549     if (m_pData == NULL) {
550         return;
551     }
552     ASSERT(nIndex >= 0);
553     ASSERT(nIndex < m_pData->m_nDataLength);
554     CopyBeforeWrite();
555     m_pData->m_String[nIndex] = ch;
556 }
557 void CFX_WideString::MakeLower()
558 {
559     if (m_pData == NULL) {
560         return;
561     }
562     CopyBeforeWrite();
563     if (GetLength() < 1) {
564         return;
565     }
566     FXSYS_wcslwr(m_pData->m_String);
567 }
568 void CFX_WideString::MakeUpper()
569 {
570     if (m_pData == NULL) {
571         return;
572     }
573     CopyBeforeWrite();
574     if (GetLength() < 1) {
575         return;
576     }
577     FXSYS_wcsupr(m_pData->m_String);
578 }
579 FX_STRSIZE CFX_WideString::Find(FX_LPCWSTR lpszSub, FX_STRSIZE nStart) const
580 {
581     FX_STRSIZE nLength = GetLength();
582     if (nLength < 1 || nStart > nLength) {
583         return -1;
584     }
585     FX_LPCWSTR lpsz = FXSYS_wcsstr(m_pData->m_String + nStart, lpszSub);
586     return (lpsz == NULL) ? -1 : (int)(lpsz - m_pData->m_String);
587 }
588 FX_STRSIZE CFX_WideString::Find(FX_WCHAR ch, FX_STRSIZE nStart) const
589 {
590     if (m_pData == NULL) {
591         return -1;
592     }
593     FX_STRSIZE nLength = m_pData->m_nDataLength;
594     if (nStart >= nLength) {
595         return -1;
596     }
597     FX_LPCWSTR lpsz = FXSYS_wcschr(m_pData->m_String + nStart, ch);
598     return (lpsz == NULL) ? -1 : (int)(lpsz - m_pData->m_String);
599 }
600 void CFX_WideString::TrimRight(FX_LPCWSTR lpszTargetList)
601 {
602     FXSYS_assert(lpszTargetList != NULL);
603     if (m_pData == NULL || *lpszTargetList == 0) {
604         return;
605     }
606     CopyBeforeWrite();
607     FX_STRSIZE len = GetLength();
608     if (len < 1) {
609         return;
610     }
611     FX_STRSIZE pos = len;
612     while (pos) {
613         if (FXSYS_wcschr(lpszTargetList, m_pData->m_String[pos - 1]) == NULL) {
614             break;
615         }
616         pos --;
617     }
618     if (pos < len) {
619         m_pData->m_String[pos] = 0;
620         m_pData->m_nDataLength = pos;
621     }
622 }
623 void CFX_WideString::TrimRight(FX_WCHAR chTarget)
624 {
625     FX_WCHAR str[2] = {chTarget, 0};
626     TrimRight(str);
627 }
628 void CFX_WideString::TrimRight()
629 {
630     TrimRight(L"\x09\x0a\x0b\x0c\x0d\x20");
631 }
632 void CFX_WideString::TrimLeft(FX_LPCWSTR lpszTargets)
633 {
634     FXSYS_assert(lpszTargets != NULL);
635     if (m_pData == NULL || *lpszTargets == 0) {
636         return;
637     }
638     CopyBeforeWrite();
639     if (GetLength() < 1) {
640         return;
641     }
642     FX_LPCWSTR lpsz = m_pData->m_String;
643     while (*lpsz != 0) {
644         if (FXSYS_wcschr(lpszTargets, *lpsz) == NULL) {
645             break;
646         }
647         lpsz ++;
648     }
649     if (lpsz != m_pData->m_String) {
650         int nDataLength = m_pData->m_nDataLength - (FX_STRSIZE)(lpsz - m_pData->m_String);
651         FXSYS_memmove32(m_pData->m_String, lpsz, (nDataLength + 1)*sizeof(FX_WCHAR));
652         m_pData->m_nDataLength = nDataLength;
653     }
654 }
655 void CFX_WideString::TrimLeft(FX_WCHAR chTarget)
656 {
657     FX_WCHAR str[2] = {chTarget, 0};
658     TrimLeft(str);
659 }
660 void CFX_WideString::TrimLeft()
661 {
662     TrimLeft(L"\x09\x0a\x0b\x0c\x0d\x20");
663 }
664 FX_STRSIZE CFX_WideString::Replace(FX_LPCWSTR lpszOld, FX_LPCWSTR lpszNew)
665 {
666     if (GetLength() < 1) {
667         return 0;
668     }
669     if (lpszOld == NULL) {
670         return 0;
671     }
672     FX_STRSIZE nSourceLen = (FX_STRSIZE)FXSYS_wcslen(lpszOld);
673     if (nSourceLen == 0) {
674         return 0;
675     }
676     FX_STRSIZE nReplacementLen = lpszNew ? (FX_STRSIZE)FXSYS_wcslen(lpszNew) : 0;
677     FX_STRSIZE nCount = 0;
678     FX_LPWSTR lpszStart = m_pData->m_String;
679     FX_LPWSTR lpszEnd = m_pData->m_String + m_pData->m_nDataLength;
680     FX_LPWSTR lpszTarget;
681     {
682         while ((lpszTarget = (FX_LPWSTR)FXSYS_wcsstr(lpszStart, lpszOld)) != NULL && lpszStart < lpszEnd) {
683             nCount++;
684             lpszStart = lpszTarget + nSourceLen;
685         }
686     }
687     if (nCount > 0) {
688         CopyBeforeWrite();
689         FX_STRSIZE nOldLength = m_pData->m_nDataLength;
690         FX_STRSIZE nNewLength =  nOldLength + (nReplacementLen - nSourceLen) * nCount;
691         if (m_pData->m_nAllocLength < nNewLength || m_pData->m_nRefs > 1) {
692             CFX_StringDataW* pOldData = m_pData;
693             FX_LPCWSTR pstr = m_pData->m_String;
694             m_pData = FX_AllocStringW(nNewLength);
695             if (!m_pData) {
696                 return 0;
697             }
698             FXSYS_memcpy32(m_pData->m_String, pstr, pOldData->m_nDataLength * sizeof(FX_WCHAR));
699             FX_ReleaseStringW(pOldData);
700         }
701         lpszStart = m_pData->m_String;
702         lpszEnd = m_pData->m_String + FX_MAX(m_pData->m_nDataLength, nNewLength);
703         {
704             while ((lpszTarget = (FX_LPWSTR)FXSYS_wcsstr(lpszStart, lpszOld)) != NULL && lpszStart < lpszEnd) {
705                 FX_STRSIZE nBalance = nOldLength - (FX_STRSIZE)(lpszTarget - m_pData->m_String + nSourceLen);
706                 FXSYS_memmove32(lpszTarget + nReplacementLen, lpszTarget + nSourceLen, nBalance * sizeof(FX_WCHAR));
707                 FXSYS_memcpy32(lpszTarget, lpszNew, nReplacementLen * sizeof(FX_WCHAR));
708                 lpszStart = lpszTarget + nReplacementLen;
709                 lpszStart[nBalance] = 0;
710                 nOldLength += (nReplacementLen - nSourceLen);
711             }
712         }
713         ASSERT(m_pData->m_String[nNewLength] == 0);
714         m_pData->m_nDataLength = nNewLength;
715     }
716     return nCount;
717 }
718 FX_STRSIZE CFX_WideString::Insert(FX_STRSIZE nIndex, FX_WCHAR ch)
719 {
720     CopyBeforeWrite();
721     if (nIndex < 0) {
722         nIndex = 0;
723     }
724     FX_STRSIZE nNewLength = GetLength();
725     if (nIndex > nNewLength) {
726         nIndex = nNewLength;
727     }
728     nNewLength++;
729     if (m_pData == NULL || m_pData->m_nAllocLength < nNewLength) {
730         CFX_StringDataW* pOldData = m_pData;
731         FX_LPCWSTR pstr = m_pData->m_String;
732         m_pData = FX_AllocStringW(nNewLength);
733         if (!m_pData) {
734             return 0;
735         }
736         if(pOldData != NULL) {
737             FXSYS_memmove32(m_pData->m_String, pstr, (pOldData->m_nDataLength + 1)*sizeof(FX_WCHAR));
738             FX_ReleaseStringW(pOldData);
739         } else {
740             m_pData->m_String[0] = 0;
741         }
742     }
743     FXSYS_memmove32(m_pData->m_String + nIndex + 1,
744                     m_pData->m_String + nIndex, (nNewLength - nIndex)*sizeof(FX_WCHAR));
745     m_pData->m_String[nIndex] = ch;
746     m_pData->m_nDataLength = nNewLength;
747     return nNewLength;
748 }
749 FX_STRSIZE CFX_WideString::Delete(FX_STRSIZE nIndex, FX_STRSIZE nCount)
750 {
751     if (GetLength() < 1) {
752         return 0;
753     }
754     if (nIndex < 0) {
755         nIndex = 0;
756     }
757     FX_STRSIZE nOldLength = m_pData->m_nDataLength;
758     if (nCount > 0 && nIndex < nOldLength) {
759         CopyBeforeWrite();
760         int nBytesToCopy = nOldLength - (nIndex + nCount) + 1;
761         FXSYS_memmove32(m_pData->m_String + nIndex,
762                         m_pData->m_String + nIndex + nCount, nBytesToCopy * sizeof(FX_WCHAR));
763         m_pData->m_nDataLength = nOldLength - nCount;
764     }
765     return m_pData->m_nDataLength;
766 }
767 FX_STRSIZE CFX_WideString::Remove(FX_WCHAR chRemove)
768 {
769     if (m_pData == NULL) {
770         return 0;
771     }
772     CopyBeforeWrite();
773     if (GetLength() < 1) {
774         return 0;
775     }
776     FX_LPWSTR pstrSource = m_pData->m_String;
777     FX_LPWSTR pstrDest = m_pData->m_String;
778     FX_LPWSTR pstrEnd = m_pData->m_String + m_pData->m_nDataLength;
779     while (pstrSource < pstrEnd) {
780         if (*pstrSource != chRemove) {
781             *pstrDest = *pstrSource;
782             pstrDest ++;
783         }
784         pstrSource ++;
785     }
786     *pstrDest = 0;
787     FX_STRSIZE nCount = (FX_STRSIZE)(pstrSource - pstrDest);
788     m_pData->m_nDataLength -= nCount;
789     return nCount;
790 }
791 #define FORCE_ANSI      0x10000
792 #define FORCE_UNICODE   0x20000
793 #define FORCE_INT64     0x40000
794 void CFX_WideString::FormatV(FX_LPCWSTR lpszFormat, va_list argList)
795 {
796     va_list argListSave;
797 #if defined(__ARMCC_VERSION) || (!defined(_MSC_VER) && (_FX_CPU_ == _FX_X64_ || _FX_CPU_ == _FX_IA64_ || _FX_CPU_ == _FX_ARM64_)) || defined(__native_client__)
798     va_copy(argListSave, argList);
799 #else
800     argListSave = argList;
801 #endif
802     int nMaxLen = 0;
803     for (FX_LPCWSTR lpsz = lpszFormat; *lpsz != 0; lpsz ++) {
804         if (*lpsz != '%' || *(lpsz = lpsz + 1) == '%') {
805             nMaxLen += (FX_STRSIZE)FXSYS_wcslen(lpsz);
806             continue;
807         }
808         int nItemLen = 0;
809         int nWidth = 0;
810         for (; *lpsz != 0; lpsz ++) {
811             if (*lpsz == '#') {
812                 nMaxLen += 2;
813             } else if (*lpsz == '*') {
814                 nWidth = va_arg(argList, int);
815             } else if (*lpsz == '-' || *lpsz == '+' || *lpsz == '0' ||
816                        *lpsz == ' ')
817                 ;
818             else {
819                 break;
820             }
821         }
822         if (nWidth == 0) {
823             nWidth = FXSYS_wtoi(lpsz);
824             for (; *lpsz != 0 && (*lpsz) <= '9' && (*lpsz) >= '0'; lpsz ++)
825                 ;
826         }
827         if (nWidth < 0 || nWidth > 128 * 1024) {
828             lpszFormat = L"Bad width";
829             nMaxLen = 10;
830             break;
831         }
832         int nPrecision = 0;
833         if (*lpsz == '.') {
834             lpsz ++;
835             if (*lpsz == '*') {
836                 nPrecision = va_arg(argList, int);
837                 lpsz ++;
838             } else {
839                 nPrecision = FXSYS_wtoi(lpsz);
840                 for (; *lpsz != 0 && (*lpsz) >= '0' && (*lpsz) <= '9'; lpsz ++)
841                     ;
842             }
843         }
844         if (nPrecision < 0 || nPrecision > 128 * 1024) {
845             lpszFormat = L"Bad precision";
846             nMaxLen = 14;
847             break;
848         }
849         int nModifier = 0;
850         if (*lpsz == L'I' && *(lpsz + 1) == L'6' && *(lpsz + 2) == L'4') {
851             lpsz += 3;
852             nModifier = FORCE_INT64;
853         } else {
854             switch (*lpsz) {
855                 case 'h':
856                     nModifier = FORCE_ANSI;
857                     lpsz ++;
858                     break;
859                 case 'l':
860                     nModifier = FORCE_UNICODE;
861                     lpsz ++;
862                     break;
863                 case 'F':
864                 case 'N':
865                 case 'L':
866                     lpsz ++;
867                     break;
868             }
869         }
870         switch (*lpsz | nModifier) {
871             case 'c':
872             case 'C':
873                 nItemLen = 2;
874                 va_arg(argList, int);
875                 break;
876             case 'c'|FORCE_ANSI:
877             case 'C'|FORCE_ANSI:
878                 nItemLen = 2;
879                 va_arg(argList, int);
880                 break;
881             case 'c'|FORCE_UNICODE:
882             case 'C'|FORCE_UNICODE:
883                 nItemLen = 2;
884                 va_arg(argList, int);
885                 break;
886             case 's': {
887                     FX_LPCWSTR pstrNextArg = va_arg(argList, FX_LPCWSTR);
888                     if (pstrNextArg == NULL) {
889                         nItemLen = 6;
890                     } else {
891                         nItemLen = (FX_STRSIZE)FXSYS_wcslen(pstrNextArg);
892                         if (nItemLen < 1) {
893                             nItemLen = 1;
894                         }
895                     }
896                 }
897                 break;
898             case 'S': {
899                     FX_LPCSTR pstrNextArg = va_arg(argList, FX_LPCSTR);
900                     if (pstrNextArg == NULL) {
901                         nItemLen = 6;
902                     } else {
903                         nItemLen = (FX_STRSIZE)FXSYS_strlen(pstrNextArg);
904                         if (nItemLen < 1) {
905                             nItemLen = 1;
906                         }
907                     }
908                 }
909                 break;
910             case 's'|FORCE_ANSI:
911             case 'S'|FORCE_ANSI: {
912                     FX_LPCSTR pstrNextArg = va_arg(argList, FX_LPCSTR);
913                     if (pstrNextArg == NULL) {
914                         nItemLen = 6;
915                     } else {
916                         nItemLen = (FX_STRSIZE)FXSYS_strlen(pstrNextArg);
917                         if (nItemLen < 1) {
918                             nItemLen = 1;
919                         }
920                     }
921                 }
922                 break;
923             case 's'|FORCE_UNICODE:
924             case 'S'|FORCE_UNICODE: {
925                     FX_LPWSTR pstrNextArg = va_arg(argList, FX_LPWSTR);
926                     if (pstrNextArg == NULL) {
927                         nItemLen = 6;
928                     } else {
929                         nItemLen = (FX_STRSIZE)FXSYS_wcslen(pstrNextArg);
930                         if (nItemLen < 1) {
931                             nItemLen = 1;
932                         }
933                     }
934                 }
935                 break;
936         }
937         if (nItemLen != 0) {
938             if (nPrecision != 0 && nItemLen > nPrecision) {
939                 nItemLen = nPrecision;
940             }
941             if (nItemLen < nWidth) {
942                 nItemLen = nWidth;
943             }
944         } else {
945             switch (*lpsz) {
946                 case 'd':
947                 case 'i':
948                 case 'u':
949                 case 'x':
950                 case 'X':
951                 case 'o':
952                     if (nModifier & FORCE_INT64) {
953                         va_arg(argList, FX_INT64);
954                     } else {
955                         va_arg(argList, int);
956                     }
957                     nItemLen = 32;
958                     if (nItemLen < nWidth + nPrecision) {
959                         nItemLen = nWidth + nPrecision;
960                     }
961                     break;
962                 case 'a':
963                 case 'A':
964                 case 'e':
965                 case 'E':
966                 case 'g':
967                 case 'G':
968                     va_arg(argList, double);
969                     nItemLen = 128;
970                     if (nItemLen < nWidth + nPrecision) {
971                         nItemLen = nWidth + nPrecision;
972                     }
973                     break;
974                 case 'f':
975                     if (nWidth + nPrecision > 100) {
976                         nItemLen = nPrecision + nWidth + 128;
977                     } else {
978                         double f;
979                         char pszTemp[256];
980                         f = va_arg(argList, double);
981                         FXSYS_snprintf(pszTemp, sizeof(pszTemp), "%*.*f", nWidth, nPrecision + 6, f );
982                         nItemLen = (FX_STRSIZE)FXSYS_strlen(pszTemp);
983                     }
984                     break;
985                 case 'p':
986                     va_arg(argList, void*);
987                     nItemLen = 32;
988                     if (nItemLen < nWidth + nPrecision) {
989                         nItemLen = nWidth + nPrecision;
990                     }
991                     break;
992                 case 'n':
993                     va_arg(argList, int*);
994                     break;
995             }
996         }
997         nMaxLen += nItemLen;
998     }
999     GetBuffer(nMaxLen);
1000     if (m_pData) {
1001         FXSYS_vswprintf((wchar_t*)m_pData->m_String, nMaxLen + 1, (const wchar_t*)lpszFormat, argListSave);
1002         ReleaseBuffer();
1003     }
1004     va_end(argListSave);
1005 }
1006 void CFX_WideString::Format(FX_LPCWSTR lpszFormat, ...)
1007 {
1008     va_list argList;
1009     va_start(argList, lpszFormat);
1010     FormatV(lpszFormat, argList);
1011     va_end(argList);
1012 }
1013 FX_FLOAT FX_wtof(FX_LPCWSTR str, int len)
1014 {
1015     if (len == 0) {
1016         return 0.0;
1017     }
1018     int cc = 0;
1019     FX_BOOL bNegative = FALSE;
1020     if (str[0] == '+') {
1021         cc++;
1022     } else if (str[0] == '-') {
1023         bNegative = TRUE;
1024         cc++;
1025     }
1026     int integer = 0;
1027     while (cc < len) {
1028         if (str[cc] == '.') {
1029             break;
1030         }
1031         integer = integer * 10 + str[cc] - '0';
1032         cc ++;
1033     }
1034     FX_FLOAT fraction = 0;
1035     if (str[cc] == '.') {
1036         cc ++;
1037         FX_FLOAT scale = 0.1f;
1038         while (cc < len) {
1039             fraction += scale * (str[cc] - '0');
1040             scale *= 0.1f;
1041             cc ++;
1042         }
1043     }
1044     fraction += (FX_FLOAT)integer;
1045     return bNegative ? -fraction : fraction;
1046 }
1047 int CFX_WideString::GetInteger() const
1048 {
1049     if (m_pData == NULL) {
1050         return 0;
1051     }
1052     return FXSYS_wtoi(m_pData->m_String);
1053 }
1054 FX_FLOAT CFX_WideString::GetFloat() const
1055 {
1056     if (m_pData == NULL) {
1057         return 0.0;
1058     }
1059     return FX_wtof(m_pData->m_String, m_pData->m_nDataLength);
1060 }
1061 static CFX_ByteString _DefMap_GetByteString(CFX_CharMap* pCharMap, const CFX_WideString& widestr)
1062 {
1063     int src_len = widestr.GetLength();
1064     int codepage = pCharMap->m_GetCodePage ? pCharMap->m_GetCodePage() : 0;
1065     int dest_len = FXSYS_WideCharToMultiByte(codepage, 0, widestr.c_str(), src_len, NULL, 0, NULL, NULL);
1066     if (dest_len == 0) {
1067         return CFX_ByteString();
1068     }
1069     CFX_ByteString bytestr;
1070     FX_LPSTR dest_buf = bytestr.GetBuffer(dest_len);
1071     FXSYS_WideCharToMultiByte(codepage, 0, widestr.c_str(), src_len, dest_buf, dest_len, NULL, NULL);
1072     bytestr.ReleaseBuffer(dest_len);
1073     return bytestr;
1074 }
1075 static CFX_WideString _DefMap_GetWideString(CFX_CharMap* pCharMap, const CFX_ByteString& bytestr)
1076 {
1077     int src_len = bytestr.GetLength();
1078     int codepage = pCharMap->m_GetCodePage ? pCharMap->m_GetCodePage() : 0;
1079     int dest_len = FXSYS_MultiByteToWideChar(codepage, 0, bytestr, src_len, NULL, 0);
1080     if (dest_len == 0) {
1081         return CFX_WideString();
1082     }
1083     CFX_WideString widestr;
1084     FX_LPWSTR dest_buf = widestr.GetBuffer(dest_len);
1085     FXSYS_MultiByteToWideChar(codepage, 0, bytestr, src_len, dest_buf, dest_len);
1086     widestr.ReleaseBuffer(dest_len);
1087     return widestr;
1088 }
1089 static int _DefMap_GetGBKCodePage()
1090 {
1091     return 936;
1092 }
1093 static int _DefMap_GetUHCCodePage()
1094 {
1095     return 949;
1096 }
1097 static int _DefMap_GetJISCodePage()
1098 {
1099     return 932;
1100 }
1101 static int _DefMap_GetBig5CodePage()
1102 {
1103     return 950;
1104 }
1105 static const CFX_CharMap g_DefaultMapper = {&_DefMap_GetWideString, &_DefMap_GetByteString, NULL};
1106 static const CFX_CharMap g_DefaultGBKMapper = {&_DefMap_GetWideString, &_DefMap_GetByteString, &_DefMap_GetGBKCodePage};
1107 static const CFX_CharMap g_DefaultJISMapper = {&_DefMap_GetWideString, &_DefMap_GetByteString, &_DefMap_GetJISCodePage};
1108 static const CFX_CharMap g_DefaultUHCMapper = {&_DefMap_GetWideString, &_DefMap_GetByteString, &_DefMap_GetUHCCodePage};
1109 static const CFX_CharMap g_DefaultBig5Mapper = {&_DefMap_GetWideString, &_DefMap_GetByteString, &_DefMap_GetBig5CodePage};
1110 CFX_CharMap* CFX_CharMap::GetDefaultMapper(FX_INT32 codepage)
1111 {
1112     switch (codepage) {
1113         case 0:
1114             return (CFX_CharMap*)&g_DefaultMapper;
1115         case 932:
1116             return (CFX_CharMap*)&g_DefaultJISMapper;
1117         case 936:
1118             return (CFX_CharMap*)&g_DefaultGBKMapper;
1119         case 949:
1120             return (CFX_CharMap*)&g_DefaultUHCMapper;
1121         case 950:
1122             return (CFX_CharMap*)&g_DefaultBig5Mapper;
1123     }
1124     return NULL;
1125 }