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