Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(572)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: core/src/fxcrt/extension.h

Issue 1265503005: clang-format all pdfium code. (Closed) Base URL: https://pdfium.googlesource.com/pdfium.git@master
Patch Set: sigh Created 5 years, 4 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp ('k') | core/src/fxcrt/fx_arabic.h » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright 2014 PDFium Authors. All rights reserved. 1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com 5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 6
7 #ifndef CORE_SRC_FXCRT_EXTENSION_H_ 7 #ifndef CORE_SRC_FXCRT_EXTENSION_H_
8 #define CORE_SRC_FXCRT_EXTENSION_H_ 8 #define CORE_SRC_FXCRT_EXTENSION_H_
9 9
10 #include "../../include/fxcrt/fx_basic.h" 10 #include "../../include/fxcrt/fx_basic.h"
11 #include "../../include/fxcrt/fx_safe_types.h" 11 #include "../../include/fxcrt/fx_safe_types.h"
12 12
13 class IFXCRT_FileAccess 13 class IFXCRT_FileAccess {
14 { 14 public:
15 public: 15 virtual ~IFXCRT_FileAccess() {}
16 virtual ~IFXCRT_FileAccess() {} 16 virtual FX_BOOL Open(const CFX_ByteStringC& fileName, FX_DWORD dwMode) = 0;
17 virtual FX_BOOL» » Open(const CFX_ByteStringC& fileName, FX_DWORD d wMode) = 0; 17 virtual FX_BOOL Open(const CFX_WideStringC& fileName, FX_DWORD dwMode) = 0;
18 virtual FX_BOOL» » Open(const CFX_WideStringC& fileName, FX_DWORD d wMode) = 0; 18 virtual void Close() = 0;
19 virtual void» » Close() = 0; 19 virtual void Release() = 0;
20 virtual void» » Release() = 0; 20 virtual FX_FILESIZE GetSize() const = 0;
21 virtual FX_FILESIZE»GetSize() const = 0; 21 virtual FX_FILESIZE GetPosition() const = 0;
22 virtual FX_FILESIZE»GetPosition() const = 0; 22 virtual FX_FILESIZE SetPosition(FX_FILESIZE pos) = 0;
23 virtual FX_FILESIZE»SetPosition(FX_FILESIZE pos) = 0; 23 virtual size_t Read(void* pBuffer, size_t szBuffer) = 0;
24 virtual size_t» » Read(void* pBuffer, size_t szBuffer) = 0; 24 virtual size_t Write(const void* pBuffer, size_t szBuffer) = 0;
25 virtual size_t» » Write(const void* pBuffer, size_t szBuffer) = 0; 25 virtual size_t ReadPos(void* pBuffer, size_t szBuffer, FX_FILESIZE pos) = 0;
26 virtual size_t» » ReadPos(void* pBuffer, size_t szBuffer, FX_FILES IZE pos) = 0; 26 virtual size_t WritePos(const void* pBuffer,
27 virtual size_t» » WritePos(const void* pBuffer, size_t szBuffer, F X_FILESIZE pos) = 0; 27 size_t szBuffer,
28 virtual FX_BOOL» » Flush() = 0; 28 FX_FILESIZE pos) = 0;
29 virtual FX_BOOL» » Truncate(FX_FILESIZE szFile) = 0; 29 virtual FX_BOOL Flush() = 0;
30 virtual FX_BOOL Truncate(FX_FILESIZE szFile) = 0;
30 }; 31 };
31 IFXCRT_FileAccess*» FXCRT_FileAccess_Create(); 32 IFXCRT_FileAccess* FXCRT_FileAccess_Create();
32 class CFX_CRTFileStream final : public IFX_FileStream 33 class CFX_CRTFileStream final : public IFX_FileStream {
33 { 34 public:
34 public: 35 CFX_CRTFileStream(IFXCRT_FileAccess* pFA)
35 CFX_CRTFileStream(IFXCRT_FileAccess* pFA) : m_pFile(pFA), m_dwCount(1), m_bU seRange(FALSE), m_nOffset(0), m_nSize(0) {} 36 : m_pFile(pFA),
36 ~CFX_CRTFileStream() 37 m_dwCount(1),
37 { 38 m_bUseRange(FALSE),
38 if (m_pFile) { 39 m_nOffset(0),
39 m_pFile->Release(); 40 m_nSize(0) {}
41 ~CFX_CRTFileStream() {
42 if (m_pFile) {
43 m_pFile->Release();
44 }
45 }
46 virtual IFX_FileStream* Retain() override {
47 m_dwCount++;
48 return this;
49 }
50 virtual void Release() override {
51 FX_DWORD nCount = --m_dwCount;
52 if (!nCount) {
53 delete this;
54 }
55 }
56 virtual FX_FILESIZE GetSize() override {
57 return m_bUseRange ? m_nSize : m_pFile->GetSize();
58 }
59 virtual FX_BOOL IsEOF() override { return GetPosition() >= GetSize(); }
60 virtual FX_FILESIZE GetPosition() override {
61 FX_FILESIZE pos = m_pFile->GetPosition();
62 if (m_bUseRange) {
63 pos -= m_nOffset;
64 }
65 return pos;
66 }
67 virtual FX_BOOL SetRange(FX_FILESIZE offset, FX_FILESIZE size) override {
68 if (offset < 0 || size < 0) {
69 return FALSE;
70 }
71
72 FX_SAFE_FILESIZE pos = size;
73 pos += offset;
74
75 if (!pos.IsValid() || pos.ValueOrDie() > m_pFile->GetSize()) {
76 return FALSE;
77 }
78
79 m_nOffset = offset, m_nSize = size;
80 m_bUseRange = TRUE;
81 m_pFile->SetPosition(m_nOffset);
82 return TRUE;
83 }
84 virtual void ClearRange() override { m_bUseRange = FALSE; }
85 virtual FX_BOOL ReadBlock(void* buffer,
86 FX_FILESIZE offset,
87 size_t size) override {
88 if (m_bUseRange && offset < 0) {
89 return FALSE;
90 }
91 FX_SAFE_FILESIZE pos = offset;
92
93 if (m_bUseRange) {
94 pos += m_nOffset;
95 if (!pos.IsValid() || pos.ValueOrDie() > (size_t)GetSize()) {
96 return FALSE;
97 }
98 }
99 return (FX_BOOL)m_pFile->ReadPos(buffer, size, pos.ValueOrDie());
100 }
101 virtual size_t ReadBlock(void* buffer, size_t size) override {
102 if (m_bUseRange) {
103 FX_FILESIZE availSize = m_nOffset + m_nSize - m_pFile->GetPosition();
104 if ((size_t)availSize < size) {
105 size -= size - (size_t)availSize;
106 }
107 }
108 return m_pFile->Read(buffer, size);
109 }
110 virtual FX_BOOL WriteBlock(const void* buffer,
111 FX_FILESIZE offset,
112 size_t size) override {
113 if (m_bUseRange) {
114 offset += m_nOffset;
115 }
116 return (FX_BOOL)m_pFile->WritePos(buffer, size, offset);
117 }
118 virtual FX_BOOL Flush() override { return m_pFile->Flush(); }
119 IFXCRT_FileAccess* m_pFile;
120 FX_DWORD m_dwCount;
121 FX_BOOL m_bUseRange;
122 FX_FILESIZE m_nOffset;
123 FX_FILESIZE m_nSize;
124 };
125 #define FX_MEMSTREAM_BlockSize (64 * 1024)
126 #define FX_MEMSTREAM_Consecutive 0x01
127 #define FX_MEMSTREAM_TakeOver 0x02
128 class CFX_MemoryStream final : public IFX_MemoryStream {
129 public:
130 CFX_MemoryStream(FX_BOOL bConsecutive)
131 : m_dwCount(1),
132 m_nTotalSize(0),
133 m_nCurSize(0),
134 m_nCurPos(0),
135 m_nGrowSize(FX_MEMSTREAM_BlockSize),
136 m_bUseRange(FALSE) {
137 m_dwFlags =
138 FX_MEMSTREAM_TakeOver | (bConsecutive ? FX_MEMSTREAM_Consecutive : 0);
139 }
140 CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, FX_BOOL bTakeOver)
141 : m_dwCount(1),
142 m_nTotalSize(nSize),
143 m_nCurSize(nSize),
144 m_nCurPos(0),
145 m_nGrowSize(FX_MEMSTREAM_BlockSize),
146 m_bUseRange(FALSE) {
147 m_Blocks.Add(pBuffer);
148 m_dwFlags =
149 FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
150 }
151 ~CFX_MemoryStream() {
152 if (m_dwFlags & FX_MEMSTREAM_TakeOver) {
153 for (int32_t i = 0; i < m_Blocks.GetSize(); i++) {
154 FX_Free((uint8_t*)m_Blocks[i]);
155 }
156 }
157 m_Blocks.RemoveAll();
158 }
159 virtual IFX_FileStream* Retain() override {
160 m_dwCount++;
161 return this;
162 }
163 virtual void Release() override {
164 FX_DWORD nCount = --m_dwCount;
165 if (nCount) {
166 return;
167 }
168 delete this;
169 }
170 virtual FX_FILESIZE GetSize() override {
171 return m_bUseRange ? (FX_FILESIZE)m_nSize : (FX_FILESIZE)m_nCurSize;
172 }
173 virtual FX_BOOL IsEOF() override { return m_nCurPos >= (size_t)GetSize(); }
174 virtual FX_FILESIZE GetPosition() override {
175 FX_FILESIZE pos = (FX_FILESIZE)m_nCurPos;
176 if (m_bUseRange) {
177 pos -= (FX_FILESIZE)m_nOffset;
178 }
179 return pos;
180 }
181 virtual FX_BOOL SetRange(FX_FILESIZE offset, FX_FILESIZE size) override {
182 if (offset < 0 || size < 0) {
183 return FALSE;
184 }
185 FX_SAFE_FILESIZE range = size;
186 range += offset;
187 if (!range.IsValid() || range.ValueOrDie() > m_nCurSize) {
188 return FALSE;
189 }
190
191 m_nOffset = (size_t)offset, m_nSize = (size_t)size;
192 m_bUseRange = TRUE;
193 m_nCurPos = m_nOffset;
194 return TRUE;
195 }
196 virtual void ClearRange() override { m_bUseRange = FALSE; }
197 virtual FX_BOOL ReadBlock(void* buffer,
198 FX_FILESIZE offset,
199 size_t size) override {
200 if (!buffer || !size) {
201 return FALSE;
202 }
203
204 FX_SAFE_FILESIZE safeOffset = offset;
205 if (m_bUseRange) {
206 safeOffset += m_nOffset;
207 }
208
209 if (!safeOffset.IsValid()) {
210 return FALSE;
211 }
212
213 offset = safeOffset.ValueOrDie();
214
215 FX_SAFE_SIZE_T newPos = size;
216 newPos += offset;
217 if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 ||
218 newPos.ValueOrDie() > m_nCurSize) {
219 return FALSE;
220 }
221
222 m_nCurPos = newPos.ValueOrDie();
223 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
224 FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
225 return TRUE;
226 }
227 size_t nStartBlock = (size_t)offset / m_nGrowSize;
228 offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
229 while (size) {
230 size_t nRead = m_nGrowSize - (size_t)offset;
231 if (nRead > size) {
232 nRead = size;
233 }
234 FXSYS_memcpy(
235 buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, nRead);
236 buffer = ((uint8_t*)buffer) + nRead;
237 size -= nRead;
238 nStartBlock++;
239 offset = 0;
240 }
241 return TRUE;
242 }
243 virtual size_t ReadBlock(void* buffer, size_t size) override {
244 if (m_nCurPos >= m_nCurSize) {
245 return 0;
246 }
247 if (m_bUseRange) {
248 size_t availSize = m_nOffset + m_nSize - m_nCurPos;
249 if (availSize < size) {
250 size -= size - (size_t)availSize;
251 }
252 }
253 size_t nRead = FX_MIN(size, m_nCurSize - m_nCurPos);
254 if (!ReadBlock(buffer, (int32_t)m_nCurPos, nRead)) {
255 return 0;
256 }
257 return nRead;
258 }
259 virtual FX_BOOL WriteBlock(const void* buffer,
260 FX_FILESIZE offset,
261 size_t size) override {
262 if (!buffer || !size) {
263 return FALSE;
264 }
265 if (m_bUseRange) {
266 offset += (FX_FILESIZE)m_nOffset;
267 }
268 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
269 FX_SAFE_SIZE_T newPos = size;
270 newPos += offset;
271 if (!newPos.IsValid())
272 return FALSE;
273
274 m_nCurPos = newPos.ValueOrDie();
275 if (m_nCurPos > m_nTotalSize) {
276 m_nTotalSize =
277 (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_nGrowSize;
278 if (m_Blocks.GetSize() < 1) {
279 void* block = FX_Alloc(uint8_t, m_nTotalSize);
280 m_Blocks.Add(block);
281 } else {
282 m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize);
40 } 283 }
41 } 284 if (!m_Blocks[0]) {
42 virtual IFX_FileStream*» » Retain() override 285 m_Blocks.RemoveAll();
43 { 286 return FALSE;
44 m_dwCount ++;
45 return this;
46 }
47 virtual void» » » » Release() override
48 {
49 FX_DWORD nCount = -- m_dwCount;
50 if (!nCount) {
51 delete this;
52 } 287 }
53 } 288 }
54 virtual FX_FILESIZE GetSize() override 289 FXSYS_memcpy((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
55 { 290 if (m_nCurSize < m_nCurPos) {
56 return m_bUseRange ? m_nSize : m_pFile->GetSize(); 291 m_nCurSize = m_nCurPos;
57 } 292 }
58 virtual FX_BOOL IsEOF() override 293 return TRUE;
59 { 294 }
60 return GetPosition() >= GetSize(); 295
61 } 296 FX_SAFE_SIZE_T newPos = size;
62 virtual FX_FILESIZE GetPosition() override 297 newPos += offset;
63 { 298 if (!newPos.IsValid()) {
64 FX_FILESIZE pos = m_pFile->GetPosition(); 299 return FALSE;
65 if (m_bUseRange) { 300 }
66 pos -= m_nOffset; 301
67 } 302 if (!ExpandBlocks(newPos.ValueOrDie())) {
68 return pos; 303 return FALSE;
69 } 304 }
70 virtual FX_BOOL SetRange(FX_FILESIZE offset, FX_ FILESIZE size) override 305 m_nCurPos = newPos.ValueOrDie();
71 { 306 size_t nStartBlock = (size_t)offset / m_nGrowSize;
72 if (offset < 0 || size < 0) { 307 offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
73 return FALSE; 308 while (size) {
74 } 309 size_t nWrite = m_nGrowSize - (size_t)offset;
75 310 if (nWrite > size) {
76 FX_SAFE_FILESIZE pos = size; 311 nWrite = size;
77 pos += offset; 312 }
78 313 FXSYS_memcpy((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset,
79 if (!pos.IsValid() || pos.ValueOrDie() > m_pFile->GetSize()) { 314 buffer, nWrite);
80 return FALSE; 315 buffer = ((uint8_t*)buffer) + nWrite;
81 } 316 size -= nWrite;
82 317 nStartBlock++;
83 m_nOffset = offset, m_nSize = size; 318 offset = 0;
84 m_bUseRange = TRUE; 319 }
85 m_pFile->SetPosition(m_nOffset); 320 return TRUE;
86 return TRUE; 321 }
87 } 322 virtual FX_BOOL Flush() override { return TRUE; }
88 virtual void ClearRange() override 323 virtual FX_BOOL IsConsecutive() const override {
89 { 324 return m_dwFlags & FX_MEMSTREAM_Consecutive;
90 m_bUseRange = FALSE; 325 }
91 } 326 virtual void EstimateSize(size_t nInitSize, size_t nGrowSize) override {
92 virtual FX_BOOL ReadBlock(void* buffer, FX_FILES IZE offset, size_t size) override 327 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
93 { 328 if (m_Blocks.GetSize() < 1) {
94 if (m_bUseRange && offset < 0) { 329 uint8_t* pBlock = FX_Alloc(uint8_t, FX_MAX(nInitSize, 4096));
95 return FALSE; 330 m_Blocks.Add(pBlock);
96 } 331 }
97 FX_SAFE_FILESIZE pos = offset; 332 m_nGrowSize = FX_MAX(nGrowSize, 4096);
98 333 } else if (m_Blocks.GetSize() < 1) {
99 if (m_bUseRange) { 334 m_nGrowSize = FX_MAX(nGrowSize, 4096);
100 pos += m_nOffset; 335 }
101 if (!pos.IsValid() || pos.ValueOrDie() > (size_t)GetSize()) { 336 }
102 return FALSE; 337 virtual uint8_t* GetBuffer() const override {
103 } 338 return m_Blocks.GetSize() ? (uint8_t*)m_Blocks[0] : NULL;
104 } 339 }
105 return (FX_BOOL)m_pFile->ReadPos(buffer, size, pos.ValueOrDie()); 340 virtual void AttachBuffer(uint8_t* pBuffer,
106 } 341 size_t nSize,
107 virtual size_t ReadBlock(void* buffer, size_t s ize) override 342 FX_BOOL bTakeOver = FALSE) override {
108 { 343 if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
109 if (m_bUseRange) { 344 return;
110 FX_FILESIZE availSize = m_nOffset + m_nSize - m_pFile->GetPosition() ; 345 }
111 if ((size_t)availSize < size) { 346 m_Blocks.RemoveAll();
112 size -= size - (size_t)availSize; 347 m_Blocks.Add(pBuffer);
113 } 348 m_nTotalSize = m_nCurSize = nSize;
114 } 349 m_nCurPos = 0;
115 return m_pFile->Read(buffer, size); 350 m_dwFlags =
116 } 351 FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOver : 0);
117 virtual FX_BOOL WriteBlock(const void* buffer, F X_FILESIZE offset, size_t size) override 352 ClearRange();
118 { 353 }
119 if (m_bUseRange) { 354 virtual void DetachBuffer() override {
120 offset += m_nOffset; 355 if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
121 } 356 return;
122 return (FX_BOOL)m_pFile->WritePos(buffer, size, offset); 357 }
123 } 358 m_Blocks.RemoveAll();
124 virtual FX_BOOL Flush() override 359 m_nTotalSize = m_nCurSize = m_nCurPos = 0;
125 { 360 m_dwFlags = FX_MEMSTREAM_TakeOver;
126 return m_pFile->Flush(); 361 ClearRange();
127 } 362 }
128 IFXCRT_FileAccess* m_pFile; 363
129 FX_DWORD m_dwCount; 364 protected:
130 FX_BOOL m_bUseRange; 365 CFX_PtrArray m_Blocks;
131 FX_FILESIZE m_nOffset; 366 FX_DWORD m_dwCount;
132 FX_FILESIZE m_nSize; 367 size_t m_nTotalSize;
133 }; 368 size_t m_nCurSize;
134 #define FX_MEMSTREAM_BlockSize (64 * 1024) 369 size_t m_nCurPos;
135 #define FX_MEMSTREAM_Consecutive 0x01 370 size_t m_nGrowSize;
136 #define FX_MEMSTREAM_TakeOver 0x02 371 FX_DWORD m_dwFlags;
137 class CFX_MemoryStream final : public IFX_MemoryStream 372 FX_BOOL m_bUseRange;
138 { 373 size_t m_nOffset;
139 public: 374 size_t m_nSize;
140 CFX_MemoryStream(FX_BOOL bConsecutive) 375 FX_BOOL ExpandBlocks(size_t size) {
141 : m_dwCount(1) 376 if (m_nCurSize < size) {
142 , m_nTotalSize(0) 377 m_nCurSize = size;
143 , m_nCurSize(0) 378 }
144 , m_nCurPos(0) 379 if (size <= m_nTotalSize) {
145 , m_nGrowSize(FX_MEMSTREAM_BlockSize) 380 return TRUE;
146 , m_bUseRange(FALSE) 381 }
147 { 382 int32_t iCount = m_Blocks.GetSize();
148 m_dwFlags = FX_MEMSTREAM_TakeOver | (bConsecutive ? FX_MEMSTREAM_Consecu tive : 0); 383 size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
149 } 384 m_Blocks.SetSize(m_Blocks.GetSize() + (int32_t)size);
150 CFX_MemoryStream(uint8_t* pBuffer, size_t nSize, FX_BOOL bTakeOver) 385 while (size--) {
151 : m_dwCount(1) 386 uint8_t* pBlock = FX_Alloc(uint8_t, m_nGrowSize);
152 , m_nTotalSize(nSize) 387 m_Blocks.SetAt(iCount++, pBlock);
153 , m_nCurSize(nSize) 388 m_nTotalSize += m_nGrowSize;
154 , m_nCurPos(0) 389 }
155 , m_nGrowSize(FX_MEMSTREAM_BlockSize) 390 return TRUE;
156 , m_bUseRange(FALSE) 391 }
157 {
158 m_Blocks.Add(pBuffer);
159 m_dwFlags = FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOve r : 0);
160 }
161 ~CFX_MemoryStream()
162 {
163 if (m_dwFlags & FX_MEMSTREAM_TakeOver) {
164 for (int32_t i = 0; i < m_Blocks.GetSize(); i++) {
165 FX_Free((uint8_t*)m_Blocks[i]);
166 }
167 }
168 m_Blocks.RemoveAll();
169 }
170 virtual IFX_FileStream* Retain() override
171 {
172 m_dwCount ++;
173 return this;
174 }
175 virtual void Release() override
176 {
177 FX_DWORD nCount = -- m_dwCount;
178 if (nCount) {
179 return;
180 }
181 delete this;
182 }
183 virtual FX_FILESIZE GetSize() override
184 {
185 return m_bUseRange ? (FX_FILESIZE) m_nSize : (FX_FILESIZE)m_nCurSize;
186 }
187 virtual FX_BOOL IsEOF() override
188 {
189 return m_nCurPos >= (size_t)GetSize();
190 }
191 virtual FX_FILESIZE GetPosition() override
192 {
193 FX_FILESIZE pos = (FX_FILESIZE)m_nCurPos;
194 if (m_bUseRange) {
195 pos -= (FX_FILESIZE)m_nOffset;
196 }
197 return pos;
198 }
199 virtual FX_BOOL SetRange(FX_FILESIZE offset, FX_ FILESIZE size) override
200 {
201 if (offset < 0 || size < 0) {
202 return FALSE;
203 }
204 FX_SAFE_FILESIZE range = size;
205 range += offset;
206 if (!range.IsValid() || range.ValueOrDie() > m_nCurSize) {
207 return FALSE;
208 }
209
210 m_nOffset = (size_t)offset, m_nSize = (size_t)size;
211 m_bUseRange = TRUE;
212 m_nCurPos = m_nOffset;
213 return TRUE;
214 }
215 virtual void ClearRange() override
216 {
217 m_bUseRange = FALSE;
218 }
219 virtual FX_BOOL ReadBlock(void* buffer, FX_FILES IZE offset, size_t size) override
220 {
221 if (!buffer || !size) {
222 return FALSE;
223 }
224
225 FX_SAFE_FILESIZE safeOffset = offset;
226 if (m_bUseRange) {
227 safeOffset += m_nOffset;
228 }
229
230 if (!safeOffset.IsValid()) {
231 return FALSE;
232 }
233
234 offset = safeOffset.ValueOrDie();
235
236 FX_SAFE_SIZE_T newPos = size;
237 newPos += offset;
238 if (!newPos.IsValid() || newPos.ValueOrDefault(0) == 0 || newPos.ValueOr Die() > m_nCurSize) {
239 return FALSE;
240 }
241
242 m_nCurPos = newPos.ValueOrDie();
243 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
244 FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[0] + (size_t)offset, size);
245 return TRUE;
246 }
247 size_t nStartBlock = (size_t)offset / m_nGrowSize;
248 offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
249 while (size) {
250 size_t nRead = m_nGrowSize - (size_t)offset;
251 if (nRead > size) {
252 nRead = size;
253 }
254 FXSYS_memcpy(buffer, (uint8_t*)m_Blocks[(int)nStartBlock] + (size_t) offset, nRead);
255 buffer = ((uint8_t*)buffer) + nRead;
256 size -= nRead;
257 nStartBlock ++;
258 offset = 0;
259 }
260 return TRUE;
261 }
262 virtual size_t ReadBlock(void* buffer, size_t s ize) override
263 {
264 if (m_nCurPos >= m_nCurSize) {
265 return 0;
266 }
267 if (m_bUseRange) {
268 size_t availSize = m_nOffset + m_nSize - m_nCurPos;
269 if (availSize < size) {
270 size -= size - (size_t)availSize;
271 }
272 }
273 size_t nRead = FX_MIN(size, m_nCurSize - m_nCurPos);
274 if (!ReadBlock(buffer, (int32_t)m_nCurPos, nRead)) {
275 return 0;
276 }
277 return nRead;
278 }
279 virtual FX_BOOL WriteBlock(const void* buffer, F X_FILESIZE offset, size_t size) override
280 {
281 if (!buffer || !size) {
282 return FALSE;
283 }
284 if (m_bUseRange) {
285 offset += (FX_FILESIZE)m_nOffset;
286 }
287 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
288 FX_SAFE_SIZE_T newPos = size;
289 newPos += offset;
290 if (!newPos.IsValid())
291 return FALSE;
292
293 m_nCurPos = newPos.ValueOrDie();
294 if (m_nCurPos > m_nTotalSize) {
295 m_nTotalSize = (m_nCurPos + m_nGrowSize - 1) / m_nGrowSize * m_n GrowSize;
296 if (m_Blocks.GetSize() < 1) {
297 void* block = FX_Alloc(uint8_t, m_nTotalSize);
298 m_Blocks.Add(block);
299 } else {
300 m_Blocks[0] = FX_Realloc(uint8_t, m_Blocks[0], m_nTotalSize) ;
301 }
302 if (!m_Blocks[0]) {
303 m_Blocks.RemoveAll();
304 return FALSE;
305 }
306 }
307 FXSYS_memcpy((uint8_t*)m_Blocks[0] + (size_t)offset, buffer, size);
308 if (m_nCurSize < m_nCurPos) {
309 m_nCurSize = m_nCurPos;
310 }
311 return TRUE;
312 }
313
314 FX_SAFE_SIZE_T newPos = size;
315 newPos += offset;
316 if (!newPos.IsValid()) {
317 return FALSE;
318 }
319
320 if (!ExpandBlocks(newPos.ValueOrDie())) {
321 return FALSE;
322 }
323 m_nCurPos = newPos.ValueOrDie();
324 size_t nStartBlock = (size_t)offset / m_nGrowSize;
325 offset -= (FX_FILESIZE)(nStartBlock * m_nGrowSize);
326 while (size) {
327 size_t nWrite = m_nGrowSize - (size_t)offset;
328 if (nWrite > size) {
329 nWrite = size;
330 }
331 FXSYS_memcpy((uint8_t*)m_Blocks[(int)nStartBlock] + (size_t)offset, buffer, nWrite);
332 buffer = ((uint8_t*)buffer) + nWrite;
333 size -= nWrite;
334 nStartBlock ++;
335 offset = 0;
336 }
337 return TRUE;
338 }
339 virtual FX_BOOL Flush() override
340 {
341 return TRUE;
342 }
343 virtual FX_BOOL IsConsecutive() const override
344 {
345 return m_dwFlags & FX_MEMSTREAM_Consecutive;
346 }
347 virtual void EstimateSize(size_t nInitSize, s ize_t nGrowSize) override
348 {
349 if (m_dwFlags & FX_MEMSTREAM_Consecutive) {
350 if (m_Blocks.GetSize() < 1) {
351 uint8_t* pBlock = FX_Alloc(uint8_t, FX_MAX(nInitSize, 4096));
352 m_Blocks.Add(pBlock);
353 }
354 m_nGrowSize = FX_MAX(nGrowSize, 4096);
355 } else if (m_Blocks.GetSize() < 1) {
356 m_nGrowSize = FX_MAX(nGrowSize, 4096);
357 }
358 }
359 virtual uint8_t* GetBuffer() const override
360 {
361 return m_Blocks.GetSize() ? (uint8_t*)m_Blocks[0] : NULL;
362 }
363 virtual void AttachBuffer(uint8_t* pBuffer, s ize_t nSize, FX_BOOL bTakeOver = FALSE) override
364 {
365 if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
366 return;
367 }
368 m_Blocks.RemoveAll();
369 m_Blocks.Add(pBuffer);
370 m_nTotalSize = m_nCurSize = nSize;
371 m_nCurPos = 0;
372 m_dwFlags = FX_MEMSTREAM_Consecutive | (bTakeOver ? FX_MEMSTREAM_TakeOve r : 0);
373 ClearRange();
374 }
375 virtual void DetachBuffer() override
376 {
377 if (!(m_dwFlags & FX_MEMSTREAM_Consecutive)) {
378 return;
379 }
380 m_Blocks.RemoveAll();
381 m_nTotalSize = m_nCurSize = m_nCurPos = 0;
382 m_dwFlags = FX_MEMSTREAM_TakeOver;
383 ClearRange();
384 }
385 protected:
386 CFX_PtrArray m_Blocks;
387 FX_DWORD m_dwCount;
388 size_t m_nTotalSize;
389 size_t m_nCurSize;
390 size_t m_nCurPos;
391 size_t m_nGrowSize;
392 FX_DWORD m_dwFlags;
393 FX_BOOL m_bUseRange;
394 size_t m_nOffset;
395 size_t m_nSize;
396 FX_BOOL ExpandBlocks(size_t size)
397 {
398 if (m_nCurSize < size) {
399 m_nCurSize = size;
400 }
401 if (size <= m_nTotalSize) {
402 return TRUE;
403 }
404 int32_t iCount = m_Blocks.GetSize();
405 size = (size - m_nTotalSize + m_nGrowSize - 1) / m_nGrowSize;
406 m_Blocks.SetSize(m_Blocks.GetSize() + (int32_t)size);
407 while (size --) {
408 uint8_t* pBlock = FX_Alloc(uint8_t, m_nGrowSize);
409 m_Blocks.SetAt(iCount ++, pBlock);
410 m_nTotalSize += m_nGrowSize;
411 }
412 return TRUE;
413 }
414 }; 392 };
415 #ifdef __cplusplus 393 #ifdef __cplusplus
416 extern "C" { 394 extern "C" {
417 #endif 395 #endif
418 #define MT_N» » » 848 396 #define MT_N 848
419 #define MT_M» » » 456 397 #define MT_M 456
420 #define MT_Matrix_A» » 0x9908b0df 398 #define MT_Matrix_A 0x9908b0df
421 #define MT_Upper_Mask» 0x80000000 399 #define MT_Upper_Mask 0x80000000
422 #define MT_Lower_Mask» 0x7fffffff 400 #define MT_Lower_Mask 0x7fffffff
423 typedef struct _FX_MTRANDOMCONTEXT { 401 typedef struct _FX_MTRANDOMCONTEXT {
424 _FX_MTRANDOMCONTEXT() 402 _FX_MTRANDOMCONTEXT() {
425 { 403 mti = MT_N + 1;
426 mti = MT_N + 1; 404 bHaveSeed = FALSE;
427 bHaveSeed = FALSE; 405 }
428 } 406 FX_DWORD mti;
429 FX_DWORD mti; 407 FX_BOOL bHaveSeed;
430 FX_BOOL» bHaveSeed; 408 FX_DWORD mt[MT_N];
431 FX_DWORD mt[MT_N]; 409 } FX_MTRANDOMCONTEXT, *FX_LPMTRANDOMCONTEXT;
432 } FX_MTRANDOMCONTEXT, * FX_LPMTRANDOMCONTEXT; 410 typedef FX_MTRANDOMCONTEXT const* FX_LPCMTRANDOMCONTEXT;
433 typedef FX_MTRANDOMCONTEXT const * FX_LPCMTRANDOMCONTEXT;
434 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_ 411 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
435 FX_BOOL FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount); 412 FX_BOOL FX_GenerateCryptoRandom(FX_DWORD* pBuffer, int32_t iCount);
436 #endif 413 #endif
437 #ifdef __cplusplus 414 #ifdef __cplusplus
438 } 415 }
439 #endif 416 #endif
440 417
441 #endif // CORE_SRC_FXCRT_EXTENSION_H_ 418 #endif // CORE_SRC_FXCRT_EXTENSION_H_
OLDNEW
« no previous file with comments | « core/src/fxcodec/jbig2/JBig2_SymbolDict.cpp ('k') | core/src/fxcrt/fx_arabic.h » ('j') | fpdfsdk/src/javascript/Consts.cpp » ('J')

Powered by Google App Engine
This is Rietveld 408576698