← Back to branch summary

~zooko/cryptopp/trunk

« back to all changes in this revision

Viewing changes to zinflate.cpp

  • Committer: weidai
  • Date: 2003-07-29 01:18:33 UTC
  • Revision ID: svn-v4:57ff6487-cd31-0410-9ec3-f628ee90f5f0:trunk/c5:118
fix potential threading problem with initialization of static objects

Show diffs side-by-side

added added

removed removed

Lines of Context:
zinflate.cpp
12
12
 
13
13
struct CodeLessThan
14
14
{
15
 
        inline bool operator()(CryptoPP::HuffmanDecoder::code_t lhs, const CryptoPP::HuffmanDecoder::CodeInfo &rhs)
 
15
        inline bool operator()(const CryptoPP::HuffmanDecoder::code_t lhs, const CryptoPP::HuffmanDecoder::CodeInfo &rhs)
16
16
                {return lhs < rhs.code;}
17
 
        // needed for MSVC .NET 2005
18
 
        inline bool operator()(const CryptoPP::HuffmanDecoder::CodeInfo &lhs, const CryptoPP::HuffmanDecoder::CodeInfo &rhs)
19
 
                {return lhs.code < rhs.code;}
20
17
};
21
18
 
22
19
inline bool LowFirstBitReader::FillBuffer(unsigned int length)
138
135
        m_normalizedCacheMask = NormalizeCode(m_cacheMask, m_cacheBits);
139
136
        assert(m_normalizedCacheMask == BitReverse(m_cacheMask));
140
137
 
141
 
        if (m_cache.size() != size_t(1) << m_cacheBits)
 
138
        if (m_cache.size() != 1 << m_cacheBits)
142
139
                m_cache.resize(1 << m_cacheBits);
143
140
 
144
141
        for (i=0; i<m_cache.size(); i++)
226
223
        m_reader.SkipBits(m_reader.BitsBuffered());
227
224
}
228
225
 
229
 
void Inflator::OutputByte(byte b)
 
226
inline void Inflator::OutputByte(byte b)
230
227
{
231
228
        m_window[m_current++] = b;
232
229
        if (m_current == m_window.size())
234
231
                ProcessDecompressedData(m_window + m_lastFlush, m_window.size() - m_lastFlush);
235
232
                m_lastFlush = 0;
236
233
                m_current = 0;
237
 
                m_wrappedAround = true;
238
234
        }
 
235
        if (m_maxDistance < m_window.size())
 
236
                m_maxDistance++;
239
237
}
240
238
 
241
 
void Inflator::OutputString(const byte *string, size_t length)
 
239
void Inflator::OutputString(const byte *string, unsigned int length)
242
240
{
243
 
        while (length)
244
 
        {
245
 
                size_t len = UnsignedMin(length, m_window.size() - m_current);
246
 
                memcpy(m_window + m_current, string, len);
247
 
                m_current += len;
248
 
                if (m_current == m_window.size())
249
 
                {
250
 
                        ProcessDecompressedData(m_window + m_lastFlush, m_window.size() - m_lastFlush);
251
 
                        m_lastFlush = 0;
252
 
                        m_current = 0;
253
 
                        m_wrappedAround = true;
254
 
                }
255
 
                string += len;
256
 
                length -= len;
257
 
        }               
 
241
        while (length--)
 
242
                OutputByte(*string++);
258
243
}
259
244
 
260
245
void Inflator::OutputPast(unsigned int length, unsigned int distance)
261
246
{
262
 
        size_t start;
263
 
        if (distance <= m_current)
 
247
        if (distance > m_maxDistance)
 
248
                throw BadBlockErr();
 
249
        unsigned int start;
 
250
        if (m_current > distance)
264
251
                start = m_current - distance;
265
 
        else if (m_wrappedAround && distance <= m_window.size())
 
252
        else
266
253
                start = m_current + m_window.size() - distance;
267
 
        else
268
 
                throw BadBlockErr();
269
254
 
270
255
        if (start + length > m_window.size())
271
256
        {
283
268
        {
284
269
                memcpy(m_window + m_current, m_window + start, length);
285
270
                m_current += length;
 
271
                m_maxDistance = STDMIN((unsigned int)m_window.size(), m_maxDistance + length);
286
272
        }
287
273
}
288
274
 
289
 
size_t Inflator::Put2(const byte *inString, size_t length, int messageEnd, bool blocking)
 
275
unsigned int Inflator::Put2(const byte *inString, unsigned int length, int messageEnd, bool blocking)
290
276
{
291
277
        if (!blocking)
292
278
                throw BlockingInputOnly("Inflator");
325
311
                                return;
326
312
                        ProcessPrestreamHeader();
327
313
                        m_state = WAIT_HEADER;
328
 
                        m_wrappedAround = false;
 
314
                        m_maxDistance = 0;
329
315
                        m_current = 0;
330
316
                        m_lastFlush = 0;
331
317
                        m_window.New(1 << GetLog2WindowSize());
333
319
                case WAIT_HEADER:
334
320
                        {
335
321
                        // maximum number of bytes before actual compressed data starts
336
 
                        const size_t MAX_HEADER_SIZE = BitsToBytes(3+5+5+4+19*7+286*15+19*15);
 
322
                        const unsigned int MAX_HEADER_SIZE = BitsToBytes(3+5+5+4+19*7+286*15+19*15);
337
323
                        if (m_inQueue.CurrentSize() < (flush ? 1 : MAX_HEADER_SIZE))
338
324
                                return;
339
325
                        DecodeHeader();
470
456
                assert(m_reader.BitsBuffered() == 0);
471
457
                while (!m_inQueue.IsEmpty() && !blockEnd)
472
458
                {
473
 
                        size_t size;
 
459
                        unsigned int size;
474
460
                        const byte *block = m_inQueue.Spy(size);
475
 
                        size = UnsignedMin(m_storedLen, size);
 
461
                        size = STDMIN(size, (unsigned int)m_storedLen);
476
462
                        OutputString(block, size);
477
463
                        m_inQueue.Skip(size);
478
 
                        m_storedLen -= (word16)size;
 
464
                        m_storedLen -= size;
479
465
                        if (m_storedLen == 0)
480
466
                                blockEnd = true;
481
467
                }