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