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