Fix fix fix of mac build breakage at 9cf44c2e
[pdfium.git] / core / src / fxcrt / fx_basic_buffer.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 FX_STRSIZE FX_ftoa(FX_FLOAT f, FX_CHAR* buf);
9 CFX_BinaryBuf::CFX_BinaryBuf()
10     : m_AllocStep(0), m_pBuffer(NULL), m_DataSize(0), m_AllocSize(0) {}
11 CFX_BinaryBuf::CFX_BinaryBuf(FX_STRSIZE size)
12     : m_AllocStep(0), m_DataSize(size), m_AllocSize(size) {
13   m_pBuffer = FX_Alloc(uint8_t, size);
14 }
15 CFX_BinaryBuf::~CFX_BinaryBuf() {
16   FX_Free(m_pBuffer);
17 }
18 void CFX_BinaryBuf::Delete(int start_index, int count) {
19   if (!m_pBuffer || start_index < 0 || start_index + count > m_DataSize) {
20     return;
21   }
22   FXSYS_memmove(m_pBuffer + start_index, m_pBuffer + start_index + count,
23                 m_DataSize - start_index - count);
24   m_DataSize -= count;
25 }
26 void CFX_BinaryBuf::Clear() {
27   m_DataSize = 0;
28 }
29 void CFX_BinaryBuf::DetachBuffer() {
30   m_DataSize = 0;
31   m_pBuffer = NULL;
32   m_AllocSize = 0;
33 }
34 void CFX_BinaryBuf::AttachData(void* buffer, FX_STRSIZE size) {
35   FX_Free(m_pBuffer);
36   m_DataSize = size;
37   m_pBuffer = (uint8_t*)buffer;
38   m_AllocSize = size;
39 }
40 void CFX_BinaryBuf::TakeOver(CFX_BinaryBuf& other) {
41   AttachData(other.GetBuffer(), other.GetSize());
42   other.DetachBuffer();
43 }
44 void CFX_BinaryBuf::EstimateSize(FX_STRSIZE size, FX_STRSIZE step) {
45   m_AllocStep = step;
46   if (m_AllocSize >= size) {
47     return;
48   }
49   ExpandBuf(size - m_DataSize);
50 }
51 void CFX_BinaryBuf::ExpandBuf(FX_STRSIZE add_size) {
52   FX_STRSIZE new_size = add_size + m_DataSize;
53   if (m_AllocSize >= new_size) {
54     return;
55   }
56   int alloc_step;
57   if (m_AllocStep == 0) {
58     alloc_step = m_AllocSize / 4;
59     if (alloc_step < 128) {
60       alloc_step = 128;
61     }
62   } else {
63     alloc_step = m_AllocStep;
64   }
65   new_size = (new_size + alloc_step - 1) / alloc_step * alloc_step;
66   uint8_t* pNewBuffer = m_pBuffer;
67   if (pNewBuffer) {
68     pNewBuffer = FX_Realloc(uint8_t, m_pBuffer, new_size);
69   } else {
70     pNewBuffer = FX_Alloc(uint8_t, new_size);
71   }
72   m_pBuffer = pNewBuffer;
73   m_AllocSize = new_size;
74 }
75 void CFX_BinaryBuf::CopyData(const void* pStr, FX_STRSIZE size) {
76   if (size == 0) {
77     m_DataSize = 0;
78     return;
79   }
80   if (m_AllocSize < size) {
81     ExpandBuf(size - m_DataSize);
82   }
83   if (!m_pBuffer) {
84     return;
85   }
86   FXSYS_memcpy(m_pBuffer, pStr, size);
87   m_DataSize = size;
88 }
89 void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size) {
90   ExpandBuf(size);
91   if (pBuf && m_pBuffer) {
92     FXSYS_memcpy(m_pBuffer + m_DataSize, pBuf, size);
93   }
94   m_DataSize += size;
95 }
96 void CFX_BinaryBuf::InsertBlock(FX_STRSIZE pos,
97                                 const void* pBuf,
98                                 FX_STRSIZE size) {
99   ExpandBuf(size);
100   if (!m_pBuffer) {
101     return;
102   }
103   FXSYS_memmove(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);
104   if (pBuf) {
105     FXSYS_memcpy(m_pBuffer + pos, pBuf, size);
106   }
107   m_DataSize += size;
108 }
109 void CFX_BinaryBuf::AppendFill(uint8_t byte, FX_STRSIZE count) {
110   ExpandBuf(count);
111   if (!m_pBuffer) {
112     return;
113   }
114   FXSYS_memset(m_pBuffer + m_DataSize, byte, count);
115   m_DataSize += count;
116 }
117 CFX_ByteStringC CFX_BinaryBuf::GetByteString() const {
118   return CFX_ByteStringC(m_pBuffer, m_DataSize);
119 }
120 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(const CFX_ByteStringC& lpsz) {
121   AppendBlock(lpsz.GetPtr(), lpsz.GetLength());
122   return *this;
123 }
124 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(int i) {
125   char buf[32];
126   FXSYS_itoa(i, buf, 10);
127   AppendBlock(buf, FXSYS_strlen(buf));
128   return *this;
129 }
130 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(FX_DWORD i) {
131   char buf[32];
132   FXSYS_itoa(i, buf, 10);
133   AppendBlock(buf, FXSYS_strlen(buf));
134   return *this;
135 }
136 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(double f) {
137   char buf[32];
138   FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);
139   AppendBlock(buf, len);
140   return *this;
141 }
142 CFX_ByteTextBuf& CFX_ByteTextBuf::operator<<(const CFX_ByteTextBuf& buf) {
143   AppendBlock(buf.m_pBuffer, buf.m_DataSize);
144   return *this;
145 }
146 void CFX_ByteTextBuf::operator=(const CFX_ByteStringC& str) {
147   CopyData(str.GetPtr(), str.GetLength());
148 }
149 void CFX_WideTextBuf::AppendChar(FX_WCHAR ch) {
150   if (m_AllocSize < m_DataSize + (FX_STRSIZE)sizeof(FX_WCHAR)) {
151     ExpandBuf(sizeof(FX_WCHAR));
152   }
153   ASSERT(m_pBuffer != NULL);
154   *(FX_WCHAR*)(m_pBuffer + m_DataSize) = ch;
155   m_DataSize += sizeof(FX_WCHAR);
156 }
157 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(const CFX_WideStringC& str) {
158   AppendBlock(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
159   return *this;
160 }
161 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(const CFX_WideString& str) {
162   AppendBlock(str.c_str(), str.GetLength() * sizeof(FX_WCHAR));
163   return *this;
164 }
165 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(int i) {
166   char buf[32];
167   FXSYS_itoa(i, buf, 10);
168   FX_STRSIZE len = FXSYS_strlen(buf);
169   if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {
170     ExpandBuf(len * sizeof(FX_WCHAR));
171   }
172   ASSERT(m_pBuffer != NULL);
173   FX_WCHAR* str = (FX_WCHAR*)(m_pBuffer + m_DataSize);
174   for (FX_STRSIZE j = 0; j < len; j++) {
175     *str++ = buf[j];
176   }
177   m_DataSize += len * sizeof(FX_WCHAR);
178   return *this;
179 }
180 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(double f) {
181   char buf[32];
182   FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);
183   if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {
184     ExpandBuf(len * sizeof(FX_WCHAR));
185   }
186   ASSERT(m_pBuffer != NULL);
187   FX_WCHAR* str = (FX_WCHAR*)(m_pBuffer + m_DataSize);
188   for (FX_STRSIZE i = 0; i < len; i++) {
189     *str++ = buf[i];
190   }
191   m_DataSize += len * sizeof(FX_WCHAR);
192   return *this;
193 }
194 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(const FX_WCHAR* lpsz) {
195   AppendBlock(lpsz, FXSYS_wcslen(lpsz) * sizeof(FX_WCHAR));
196   return *this;
197 }
198 CFX_WideTextBuf& CFX_WideTextBuf::operator<<(const CFX_WideTextBuf& buf) {
199   AppendBlock(buf.m_pBuffer, buf.m_DataSize);
200   return *this;
201 }
202 void CFX_WideTextBuf::operator=(const CFX_WideStringC& str) {
203   CopyData(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
204 }
205 CFX_WideStringC CFX_WideTextBuf::GetWideString() const {
206   return CFX_WideStringC((const FX_WCHAR*)m_pBuffer,
207                          m_DataSize / sizeof(FX_WCHAR));
208 }
209 void CFX_BitStream::Init(const uint8_t* pData, FX_DWORD dwSize) {
210   m_pData = pData;
211   m_BitSize = dwSize * 8;
212   m_BitPos = 0;
213 }
214 void CFX_BitStream::ByteAlign() {
215   int mod = m_BitPos % 8;
216   if (mod == 0) {
217     return;
218   }
219   m_BitPos += 8 - mod;
220 }
221 FX_DWORD CFX_BitStream::GetBits(FX_DWORD nBits) {
222   if (nBits > m_BitSize || m_BitPos + nBits > m_BitSize) {
223     return 0;
224   }
225   if (nBits == 1) {
226     int bit = (m_pData[m_BitPos / 8] & (1 << (7 - m_BitPos % 8))) ? 1 : 0;
227     m_BitPos++;
228     return bit;
229   }
230   FX_DWORD byte_pos = m_BitPos / 8;
231   FX_DWORD bit_pos = m_BitPos % 8, bit_left = nBits;
232   FX_DWORD result = 0;
233   if (bit_pos) {
234     if (8 - bit_pos >= bit_left) {
235       result =
236           (m_pData[byte_pos] & (0xff >> bit_pos)) >> (8 - bit_pos - bit_left);
237       m_BitPos += bit_left;
238       return result;
239     }
240     bit_left -= 8 - bit_pos;
241     result = (m_pData[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
242   }
243   while (bit_left >= 8) {
244     bit_left -= 8;
245     result |= m_pData[byte_pos++] << bit_left;
246   }
247   if (bit_left) {
248     result |= m_pData[byte_pos] >> (8 - bit_left);
249   }
250   m_BitPos += nBits;
251   return result;
252 }
253 IFX_BufferArchive::IFX_BufferArchive(FX_STRSIZE size)
254     : m_BufSize(size), m_pBuffer(NULL), m_Length(0) {}
255 void IFX_BufferArchive::Clear() {
256   m_Length = 0;
257   FX_Free(m_pBuffer);
258   m_pBuffer = NULL;
259 }
260 FX_BOOL IFX_BufferArchive::Flush() {
261   FX_BOOL bRet = DoWork(m_pBuffer, m_Length);
262   m_Length = 0;
263   return bRet;
264 }
265 int32_t IFX_BufferArchive::AppendBlock(const void* pBuf, size_t size) {
266   if (!pBuf || size < 1) {
267     return 0;
268   }
269   if (!m_pBuffer) {
270     m_pBuffer = FX_Alloc(uint8_t, m_BufSize);
271   }
272   uint8_t* buffer = (uint8_t*)pBuf;
273   FX_STRSIZE temp_size = (FX_STRSIZE)size;
274   while (temp_size > 0) {
275     FX_STRSIZE buf_size = FX_MIN(m_BufSize - m_Length, (FX_STRSIZE)temp_size);
276     FXSYS_memcpy(m_pBuffer + m_Length, buffer, buf_size);
277     m_Length += buf_size;
278     if (m_Length == m_BufSize) {
279       if (!Flush()) {
280         return -1;
281       }
282     }
283     temp_size -= buf_size;
284     buffer += buf_size;
285   }
286   return (int32_t)size;
287 }
288 int32_t IFX_BufferArchive::AppendByte(uint8_t byte) {
289   return AppendBlock(&byte, 1);
290 }
291 int32_t IFX_BufferArchive::AppendDWord(FX_DWORD i) {
292   char buf[32];
293   FXSYS_itoa(i, buf, 10);
294   return AppendBlock(buf, (size_t)FXSYS_strlen(buf));
295 }
296 int32_t IFX_BufferArchive::AppendString(const CFX_ByteStringC& lpsz) {
297   return AppendBlock(lpsz.GetPtr(), lpsz.GetLength());
298 }
299 CFX_FileBufferArchive::CFX_FileBufferArchive(FX_STRSIZE size)
300     : IFX_BufferArchive(size), m_pFile(NULL), m_bTakeover(FALSE) {}
301 CFX_FileBufferArchive::~CFX_FileBufferArchive() {
302   Clear();
303 }
304 void CFX_FileBufferArchive::Clear() {
305   if (m_pFile && m_bTakeover) {
306     m_pFile->Release();
307   }
308   m_pFile = NULL;
309   m_bTakeover = FALSE;
310   IFX_BufferArchive::Clear();
311 }
312 FX_BOOL CFX_FileBufferArchive::AttachFile(IFX_StreamWrite* pFile,
313                                           FX_BOOL bTakeover) {
314   if (!pFile) {
315     return FALSE;
316   }
317   if (m_pFile && m_bTakeover) {
318     m_pFile->Release();
319   }
320   m_pFile = pFile;
321   m_bTakeover = bTakeover;
322   return TRUE;
323 }
324 FX_BOOL CFX_FileBufferArchive::DoWork(const void* pBuf, size_t size) {
325   if (!m_pFile) {
326     return FALSE;
327   }
328   if (!pBuf || size < 1) {
329     return TRUE;
330   }
331   return m_pFile->WriteBlock(pBuf, size);
332 }