← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to win32/3rdparty/bzip2/decompress.c

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
win32/3rdparty/bzip2/decompress.c
1
 
 
2
 
/*-------------------------------------------------------------*/
3
 
/*--- Decompression machinery                               ---*/
4
 
/*---                                          decompress.c ---*/
5
 
/*-------------------------------------------------------------*/
6
 
 
7
 
/* ------------------------------------------------------------------
8
 
   This file is part of bzip2/libbzip2, a program and library for
9
 
   lossless, block-sorting data compression.
10
 
 
11
 
   bzip2/libbzip2 version 1.0.6 of 6 September 2010
12
 
   Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
13
 
 
14
 
   Please read the WARNING, DISCLAIMER and PATENTS sections in the 
15
 
   README file.
16
 
 
17
 
   This program is released under the terms of the license contained
18
 
   in the file LICENSE.
19
 
   ------------------------------------------------------------------ */
20
 
 
21
 
 
22
 
#include "bzlib_private.h"
23
 
 
24
 
 
25
 
/*---------------------------------------------------*/
26
 
static
27
 
void makeMaps_d ( DState* s )
28
 
{
29
 
   Int32 i;
30
 
   s->nInUse = 0;
31
 
   for (i = 0; i < 256; i++)
32
 
      if (s->inUse[i]) {
33
 
         s->seqToUnseq[s->nInUse] = i;
34
 
         s->nInUse++;
35
 
      }
36
 
}
37
 
 
38
 
 
39
 
/*---------------------------------------------------*/
40
 
#define RETURN(rrr)                               \
41
 
   { retVal = rrr; goto save_state_and_return; };
42
 
 
43
 
#define GET_BITS(lll,vvv,nnn)                     \
44
 
   case lll: s->state = lll;                      \
45
 
   while (True) {                                 \
46
 
      if (s->bsLive >= nnn) {                     \
47
 
         UInt32 v;                                \
48
 
         v = (s->bsBuff >>                        \
49
 
             (s->bsLive-nnn)) & ((1 << nnn)-1);   \
50
 
         s->bsLive -= nnn;                        \
51
 
         vvv = v;                                 \
52
 
         break;                                   \
53
 
      }                                           \
54
 
      if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
55
 
      s->bsBuff                                   \
56
 
         = (s->bsBuff << 8) |                     \
57
 
           ((UInt32)                              \
58
 
              (*((UChar*)(s->strm->next_in))));   \
59
 
      s->bsLive += 8;                             \
60
 
      s->strm->next_in++;                         \
61
 
      s->strm->avail_in--;                        \
62
 
      s->strm->total_in_lo32++;                   \
63
 
      if (s->strm->total_in_lo32 == 0)            \
64
 
         s->strm->total_in_hi32++;                \
65
 
   }
66
 
 
67
 
#define GET_UCHAR(lll,uuu)                        \
68
 
   GET_BITS(lll,uuu,8)
69
 
 
70
 
#define GET_BIT(lll,uuu)                          \
71
 
   GET_BITS(lll,uuu,1)
72
 
 
73
 
/*---------------------------------------------------*/
74
 
#define GET_MTF_VAL(label1,label2,lval)           \
75
 
{                                                 \
76
 
   if (groupPos == 0) {                           \
77
 
      groupNo++;                                  \
78
 
      if (groupNo >= nSelectors)                  \
79
 
         RETURN(BZ_DATA_ERROR);                   \
80
 
      groupPos = BZ_G_SIZE;                       \
81
 
      gSel = s->selector[groupNo];                \
82
 
      gMinlen = s->minLens[gSel];                 \
83
 
      gLimit = &(s->limit[gSel][0]);              \
84
 
      gPerm = &(s->perm[gSel][0]);                \
85
 
      gBase = &(s->base[gSel][0]);                \
86
 
   }                                              \
87
 
   groupPos--;                                    \
88
 
   zn = gMinlen;                                  \
89
 
   GET_BITS(label1, zvec, zn);                    \
90
 
   while (1) {                                    \
91
 
      if (zn > 20 /* the longest code */)         \
92
 
         RETURN(BZ_DATA_ERROR);                   \
93
 
      if (zvec <= gLimit[zn]) break;              \
94
 
      zn++;                                       \
95
 
      GET_BIT(label2, zj);                        \
96
 
      zvec = (zvec << 1) | zj;                    \
97
 
   };                                             \
98
 
   if (zvec - gBase[zn] < 0                       \
99
 
       || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
100
 
      RETURN(BZ_DATA_ERROR);                      \
101
 
   lval = gPerm[zvec - gBase[zn]];                \
102
 
}
103
 
 
104
 
 
105
 
/*---------------------------------------------------*/
106
 
Int32 BZ2_decompress ( DState* s )
107
 
{
108
 
   UChar      uc;
109
 
   Int32      retVal;
110
 
   Int32      minLen, maxLen;
111
 
   bz_stream* strm = s->strm;
112
 
 
113
 
   /* stuff that needs to be saved/restored */
114
 
   Int32  i;
115
 
   Int32  j;
116
 
   Int32  t;
117
 
   Int32  alphaSize;
118
 
   Int32  nGroups;
119
 
   Int32  nSelectors;
120
 
   Int32  EOB;
121
 
   Int32  groupNo;
122
 
   Int32  groupPos;
123
 
   Int32  nextSym;
124
 
   Int32  nblockMAX;
125
 
   Int32  nblock;
126
 
   Int32  es;
127
 
   Int32  N;
128
 
   Int32  curr;
129
 
   Int32  zt;
130
 
   Int32  zn; 
131
 
   Int32  zvec;
132
 
   Int32  zj;
133
 
   Int32  gSel;
134
 
   Int32  gMinlen;
135
 
   Int32* gLimit;
136
 
   Int32* gBase;
137
 
   Int32* gPerm;
138
 
 
139
 
   if (s->state == BZ_X_MAGIC_1) {
140
 
      /*initialise the save area*/
141
 
      s->save_i           = 0;
142
 
      s->save_j           = 0;
143
 
      s->save_t           = 0;
144
 
      s->save_alphaSize   = 0;
145
 
      s->save_nGroups     = 0;
146
 
      s->save_nSelectors  = 0;
147
 
      s->save_EOB         = 0;
148
 
      s->save_groupNo     = 0;
149
 
      s->save_groupPos    = 0;
150
 
      s->save_nextSym     = 0;
151
 
      s->save_nblockMAX   = 0;
152
 
      s->save_nblock      = 0;
153
 
      s->save_es          = 0;
154
 
      s->save_N           = 0;
155
 
      s->save_curr        = 0;
156
 
      s->save_zt          = 0;
157
 
      s->save_zn          = 0;
158
 
      s->save_zvec        = 0;
159
 
      s->save_zj          = 0;
160
 
      s->save_gSel        = 0;
161
 
      s->save_gMinlen     = 0;
162
 
      s->save_gLimit      = NULL;
163
 
      s->save_gBase       = NULL;
164
 
      s->save_gPerm       = NULL;
165
 
   }
166
 
 
167
 
   /*restore from the save area*/
168
 
   i           = s->save_i;
169
 
   j           = s->save_j;
170
 
   t           = s->save_t;
171
 
   alphaSize   = s->save_alphaSize;
172
 
   nGroups     = s->save_nGroups;
173
 
   nSelectors  = s->save_nSelectors;
174
 
   EOB         = s->save_EOB;
175
 
   groupNo     = s->save_groupNo;
176
 
   groupPos    = s->save_groupPos;
177
 
   nextSym     = s->save_nextSym;
178
 
   nblockMAX   = s->save_nblockMAX;
179
 
   nblock      = s->save_nblock;
180
 
   es          = s->save_es;
181
 
   N           = s->save_N;
182
 
   curr        = s->save_curr;
183
 
   zt          = s->save_zt;
184
 
   zn          = s->save_zn; 
185
 
   zvec        = s->save_zvec;
186
 
   zj          = s->save_zj;
187
 
   gSel        = s->save_gSel;
188
 
   gMinlen     = s->save_gMinlen;
189
 
   gLimit      = s->save_gLimit;
190
 
   gBase       = s->save_gBase;
191
 
   gPerm       = s->save_gPerm;
192
 
 
193
 
   retVal = BZ_OK;
194
 
 
195
 
   switch (s->state) {
196
 
 
197
 
      GET_UCHAR(BZ_X_MAGIC_1, uc);
198
 
      if (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC);
199
 
 
200
 
      GET_UCHAR(BZ_X_MAGIC_2, uc);
201
 
      if (uc != BZ_HDR_Z) RETURN(BZ_DATA_ERROR_MAGIC);
202
 
 
203
 
      GET_UCHAR(BZ_X_MAGIC_3, uc)
204
 
      if (uc != BZ_HDR_h) RETURN(BZ_DATA_ERROR_MAGIC);
205
 
 
206
 
      GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
207
 
      if (s->blockSize100k < (BZ_HDR_0 + 1) || 
208
 
          s->blockSize100k > (BZ_HDR_0 + 9)) RETURN(BZ_DATA_ERROR_MAGIC);
209
 
      s->blockSize100k -= BZ_HDR_0;
210
 
 
211
 
      if (s->smallDecompress) {
212
 
         s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
213
 
         s->ll4  = BZALLOC( 
214
 
                      ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) 
215
 
                   );
216
 
         if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
217
 
      } else {
218
 
         s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
219
 
         if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
220
 
      }
221
 
 
222
 
      GET_UCHAR(BZ_X_BLKHDR_1, uc);
223
 
 
224
 
      if (uc == 0x17) goto endhdr_2;
225
 
      if (uc != 0x31) RETURN(BZ_DATA_ERROR);
226
 
      GET_UCHAR(BZ_X_BLKHDR_2, uc);
227
 
      if (uc != 0x41) RETURN(BZ_DATA_ERROR);
228
 
      GET_UCHAR(BZ_X_BLKHDR_3, uc);
229
 
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
230
 
      GET_UCHAR(BZ_X_BLKHDR_4, uc);
231
 
      if (uc != 0x26) RETURN(BZ_DATA_ERROR);
232
 
      GET_UCHAR(BZ_X_BLKHDR_5, uc);
233
 
      if (uc != 0x53) RETURN(BZ_DATA_ERROR);
234
 
      GET_UCHAR(BZ_X_BLKHDR_6, uc);
235
 
      if (uc != 0x59) RETURN(BZ_DATA_ERROR);
236
 
 
237
 
      s->currBlockNo++;
238
 
      if (s->verbosity >= 2)
239
 
         VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
240
 
 
241
 
      s->storedBlockCRC = 0;
242
 
      GET_UCHAR(BZ_X_BCRC_1, uc);
243
 
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
244
 
      GET_UCHAR(BZ_X_BCRC_2, uc);
245
 
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
246
 
      GET_UCHAR(BZ_X_BCRC_3, uc);
247
 
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
248
 
      GET_UCHAR(BZ_X_BCRC_4, uc);
249
 
      s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
250
 
 
251
 
      GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
252
 
 
253
 
      s->origPtr = 0;
254
 
      GET_UCHAR(BZ_X_ORIGPTR_1, uc);
255
 
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
256
 
      GET_UCHAR(BZ_X_ORIGPTR_2, uc);
257
 
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
258
 
      GET_UCHAR(BZ_X_ORIGPTR_3, uc);
259
 
      s->origPtr = (s->origPtr << 8) | ((Int32)uc);
260
 
 
261
 
      if (s->origPtr < 0)
262
 
         RETURN(BZ_DATA_ERROR);
263
 
      if (s->origPtr > 10 + 100000*s->blockSize100k) 
264
 
         RETURN(BZ_DATA_ERROR);
265
 
 
266
 
      /*--- Receive the mapping table ---*/
267
 
      for (i = 0; i < 16; i++) {
268
 
         GET_BIT(BZ_X_MAPPING_1, uc);
269
 
         if (uc == 1) 
270
 
            s->inUse16[i] = True; else 
271
 
            s->inUse16[i] = False;
272
 
      }
273
 
 
274
 
      for (i = 0; i < 256; i++) s->inUse[i] = False;
275
 
 
276
 
      for (i = 0; i < 16; i++)
277
 
         if (s->inUse16[i])
278
 
            for (j = 0; j < 16; j++) {
279
 
               GET_BIT(BZ_X_MAPPING_2, uc);
280
 
               if (uc == 1) s->inUse[i * 16 + j] = True;
281
 
            }
282
 
      makeMaps_d ( s );
283
 
      if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
284
 
      alphaSize = s->nInUse+2;
285
 
 
286
 
      /*--- Now the selectors ---*/
287
 
      GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
288
 
      if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
289
 
      GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
290
 
      if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
291
 
      for (i = 0; i < nSelectors; i++) {
292
 
         j = 0;
293
 
         while (True) {
294
 
            GET_BIT(BZ_X_SELECTOR_3, uc);
295
 
            if (uc == 0) break;
296
 
            j++;
297
 
            if (j >= nGroups) RETURN(BZ_DATA_ERROR);
298
 
         }
299
 
         s->selectorMtf[i] = j;
300
 
      }
301
 
 
302
 
      /*--- Undo the MTF values for the selectors. ---*/
303
 
      {
304
 
         UChar pos[BZ_N_GROUPS], tmp, v;
305
 
         for (v = 0; v < nGroups; v++) pos[v] = v;
306
 
   
307
 
         for (i = 0; i < nSelectors; i++) {
308
 
            v = s->selectorMtf[i];
309
 
            tmp = pos[v];
310
 
            while (v > 0) { pos[v] = pos[v-1]; v--; }
311
 
            pos[0] = tmp;
312
 
            s->selector[i] = tmp;
313
 
         }
314
 
      }
315
 
 
316
 
      /*--- Now the coding tables ---*/
317
 
      for (t = 0; t < nGroups; t++) {
318
 
         GET_BITS(BZ_X_CODING_1, curr, 5);
319
 
         for (i = 0; i < alphaSize; i++) {
320
 
            while (True) {
321
 
               if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
322
 
               GET_BIT(BZ_X_CODING_2, uc);
323
 
               if (uc == 0) break;
324
 
               GET_BIT(BZ_X_CODING_3, uc);
325
 
               if (uc == 0) curr++; else curr--;
326
 
            }
327
 
            s->len[t][i] = curr;
328
 
         }
329
 
      }
330
 
 
331
 
      /*--- Create the Huffman decoding tables ---*/
332
 
      for (t = 0; t < nGroups; t++) {
333
 
         minLen = 32;
334
 
         maxLen = 0;
335
 
         for (i = 0; i < alphaSize; i++) {
336
 
            if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
337
 
            if (s->len[t][i] < minLen) minLen = s->len[t][i];
338
 
         }
339
 
         BZ2_hbCreateDecodeTables ( 
340
 
            &(s->limit[t][0]), 
341
 
            &(s->base[t][0]), 
342
 
            &(s->perm[t][0]), 
343
 
            &(s->len[t][0]),
344
 
            minLen, maxLen, alphaSize
345
 
         );
346
 
         s->minLens[t] = minLen;
347
 
      }
348
 
 
349
 
      /*--- Now the MTF values ---*/
350
 
 
351
 
      EOB      = s->nInUse+1;
352
 
      nblockMAX = 100000 * s->blockSize100k;
353
 
      groupNo  = -1;
354
 
      groupPos = 0;
355
 
 
356
 
      for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
357
 
 
358
 
      /*-- MTF init --*/
359
 
      {
360
 
         Int32 ii, jj, kk;
361
 
         kk = MTFA_SIZE-1;
362
 
         for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
363
 
            for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
364
 
               s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
365
 
               kk--;
366
 
            }
367
 
            s->mtfbase[ii] = kk + 1;
368
 
         }
369
 
      }
370
 
      /*-- end MTF init --*/
371
 
 
372
 
      nblock = 0;
373
 
      GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
374
 
 
375
 
      while (True) {
376
 
 
377
 
         if (nextSym == EOB) break;
378
 
 
379
 
         if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
380
 
 
381
 
            es = -1;
382
 
            N = 1;
383
 
            do {
384
 
               /* Check that N doesn't get too big, so that es doesn't
385
 
                  go negative.  The maximum value that can be
386
 
                  RUNA/RUNB encoded is equal to the block size (post
387
 
                  the initial RLE), viz, 900k, so bounding N at 2
388
 
                  million should guard against overflow without
389
 
                  rejecting any legitimate inputs. */
390
 
               if (N >= 2*1024*1024) RETURN(BZ_DATA_ERROR);
391
 
               if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
392
 
               if (nextSym == BZ_RUNB) es = es + (1+1) * N;
393
 
               N = N * 2;
394
 
               GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
395
 
            }
396
 
               while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
397
 
 
398
 
            es++;
399
 
            uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
400
 
            s->unzftab[uc] += es;
401
 
 
402
 
            if (s->smallDecompress)
403
 
               while (es > 0) {
404
 
                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
405
 
                  s->ll16[nblock] = (UInt16)uc;
406
 
                  nblock++;
407
 
                  es--;
408
 
               }
409
 
            else
410
 
               while (es > 0) {
411
 
                  if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
412
 
                  s->tt[nblock] = (UInt32)uc;
413
 
                  nblock++;
414
 
                  es--;
415
 
               };
416
 
 
417
 
            continue;
418
 
 
419
 
         } else {
420
 
 
421
 
            if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
422
 
 
423
 
            /*-- uc = MTF ( nextSym-1 ) --*/
424
 
            {
425
 
               Int32 ii, jj, kk, pp, lno, off;
426
 
               UInt32 nn;
427
 
               nn = (UInt32)(nextSym - 1);
428
 
 
429
 
               if (nn < MTFL_SIZE) {
430
 
                  /* avoid general-case expense */
431
 
                  pp = s->mtfbase[0];
432
 
                  uc = s->mtfa[pp+nn];
433
 
                  while (nn > 3) {
434
 
                     Int32 z = pp+nn;
435
 
                     s->mtfa[(z)  ] = s->mtfa[(z)-1];
436
 
                     s->mtfa[(z)-1] = s->mtfa[(z)-2];
437
 
                     s->mtfa[(z)-2] = s->mtfa[(z)-3];
438
 
                     s->mtfa[(z)-3] = s->mtfa[(z)-4];
439
 
                     nn -= 4;
440
 
                  }
441
 
                  while (nn > 0) { 
442
 
                     s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; 
443
 
                  };
444
 
                  s->mtfa[pp] = uc;
445
 
               } else { 
446
 
                  /* general case */
447
 
                  lno = nn / MTFL_SIZE;
448
 
                  off = nn % MTFL_SIZE;
449
 
                  pp = s->mtfbase[lno] + off;
450
 
                  uc = s->mtfa[pp];
451
 
                  while (pp > s->mtfbase[lno]) { 
452
 
                     s->mtfa[pp] = s->mtfa[pp-1]; pp--; 
453
 
                  };
454
 
                  s->mtfbase[lno]++;
455
 
                  while (lno > 0) {
456
 
                     s->mtfbase[lno]--;
457
 
                     s->mtfa[s->mtfbase[lno]] 
458
 
                        = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
459
 
                     lno--;
460
 
                  }
461
 
                  s->mtfbase[0]--;
462
 
                  s->mtfa[s->mtfbase[0]] = uc;
463
 
                  if (s->mtfbase[0] == 0) {
464
 
                     kk = MTFA_SIZE-1;
465
 
                     for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
466
 
                        for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
467
 
                           s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
468
 
                           kk--;
469
 
                        }
470
 
                        s->mtfbase[ii] = kk + 1;
471
 
                     }
472
 
                  }
473
 
               }
474
 
            }
475
 
            /*-- end uc = MTF ( nextSym-1 ) --*/
476
 
 
477
 
            s->unzftab[s->seqToUnseq[uc]]++;
478
 
            if (s->smallDecompress)
479
 
               s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
480
 
               s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
481
 
            nblock++;
482
 
 
483
 
            GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
484
 
            continue;
485
 
         }
486
 
      }
487
 
 
488
 
      /* Now we know what nblock is, we can do a better sanity
489
 
         check on s->origPtr.
490
 
      */
491
 
      if (s->origPtr < 0 || s->origPtr >= nblock)
492
 
         RETURN(BZ_DATA_ERROR);
493
 
 
494
 
      /*-- Set up cftab to facilitate generation of T^(-1) --*/
495
 
      /* Check: unzftab entries in range. */
496
 
      for (i = 0; i <= 255; i++) {
497
 
         if (s->unzftab[i] < 0 || s->unzftab[i] > nblock)
498
 
            RETURN(BZ_DATA_ERROR);
499
 
      }
500
 
      /* Actually generate cftab. */
501
 
      s->cftab[0] = 0;
502
 
      for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
503
 
      for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
504
 
      /* Check: cftab entries in range. */
505
 
      for (i = 0; i <= 256; i++) {
506
 
         if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
507
 
            /* s->cftab[i] can legitimately be == nblock */
508
 
            RETURN(BZ_DATA_ERROR);
509
 
         }
510
 
      }
511
 
      /* Check: cftab entries non-descending. */
512
 
      for (i = 1; i <= 256; i++) {
513
 
         if (s->cftab[i-1] > s->cftab[i]) {
514
 
            RETURN(BZ_DATA_ERROR);
515
 
         }
516
 
      }
517
 
 
518
 
      s->state_out_len = 0;
519
 
      s->state_out_ch  = 0;
520
 
      BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
521
 
      s->state = BZ_X_OUTPUT;
522
 
      if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
523
 
 
524
 
      if (s->smallDecompress) {
525
 
 
526
 
         /*-- Make a copy of cftab, used in generation of T --*/
527
 
         for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
528
 
 
529
 
         /*-- compute the T vector --*/
530
 
         for (i = 0; i < nblock; i++) {
531
 
            uc = (UChar)(s->ll16[i]);
532
 
            SET_LL(i, s->cftabCopy[uc]);
533
 
            s->cftabCopy[uc]++;
534
 
         }
535
 
 
536
 
         /*-- Compute T^(-1) by pointer reversal on T --*/
537
 
         i = s->origPtr;
538
 
         j = GET_LL(i);
539
 
         do {
540
 
            Int32 tmp = GET_LL(j);
541
 
            SET_LL(j, i);
542
 
            i = j;
543
 
            j = tmp;
544
 
         }
545
 
            while (i != s->origPtr);
546
 
 
547
 
         s->tPos = s->origPtr;
548
 
         s->nblock_used = 0;
549
 
         if (s->blockRandomised) {
550
 
            BZ_RAND_INIT_MASK;
551
 
            BZ_GET_SMALL(s->k0); s->nblock_used++;
552
 
            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
553
 
         } else {
554
 
            BZ_GET_SMALL(s->k0); s->nblock_used++;
555
 
         }
556
 
 
557
 
      } else {
558
 
 
559
 
         /*-- compute the T^(-1) vector --*/
560
 
         for (i = 0; i < nblock; i++) {
561
 
            uc = (UChar)(s->tt[i] & 0xff);
562
 
            s->tt[s->cftab[uc]] |= (i << 8);
563
 
            s->cftab[uc]++;
564
 
         }
565
 
 
566
 
         s->tPos = s->tt[s->origPtr] >> 8;
567
 
         s->nblock_used = 0;
568
 
         if (s->blockRandomised) {
569
 
            BZ_RAND_INIT_MASK;
570
 
            BZ_GET_FAST(s->k0); s->nblock_used++;
571
 
            BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
572
 
         } else {
573
 
            BZ_GET_FAST(s->k0); s->nblock_used++;
574
 
         }
575
 
 
576
 
      }
577
 
 
578
 
      RETURN(BZ_OK);
579
 
 
580
 
 
581
 
 
582
 
    endhdr_2:
583
 
 
584
 
      GET_UCHAR(BZ_X_ENDHDR_2, uc);
585
 
      if (uc != 0x72) RETURN(BZ_DATA_ERROR);
586
 
      GET_UCHAR(BZ_X_ENDHDR_3, uc);
587
 
      if (uc != 0x45) RETURN(BZ_DATA_ERROR);
588
 
      GET_UCHAR(BZ_X_ENDHDR_4, uc);
589
 
      if (uc != 0x38) RETURN(BZ_DATA_ERROR);
590
 
      GET_UCHAR(BZ_X_ENDHDR_5, uc);
591
 
      if (uc != 0x50) RETURN(BZ_DATA_ERROR);
592
 
      GET_UCHAR(BZ_X_ENDHDR_6, uc);
593
 
      if (uc != 0x90) RETURN(BZ_DATA_ERROR);
594
 
 
595
 
      s->storedCombinedCRC = 0;
596
 
      GET_UCHAR(BZ_X_CCRC_1, uc);
597
 
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
598
 
      GET_UCHAR(BZ_X_CCRC_2, uc);
599
 
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
600
 
      GET_UCHAR(BZ_X_CCRC_3, uc);
601
 
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
602
 
      GET_UCHAR(BZ_X_CCRC_4, uc);
603
 
      s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
604
 
 
605
 
      s->state = BZ_X_IDLE;
606
 
      RETURN(BZ_STREAM_END);
607
 
 
608
 
      default: AssertH ( False, 4001 );
609
 
   }
610
 
 
611
 
   AssertH ( False, 4002 );
612
 
 
613
 
   save_state_and_return:
614
 
 
615
 
   s->save_i           = i;
616
 
   s->save_j           = j;
617
 
   s->save_t           = t;
618
 
   s->save_alphaSize   = alphaSize;
619
 
   s->save_nGroups     = nGroups;
620
 
   s->save_nSelectors  = nSelectors;
621
 
   s->save_EOB         = EOB;
622
 
   s->save_groupNo     = groupNo;
623
 
   s->save_groupPos    = groupPos;
624
 
   s->save_nextSym     = nextSym;
625
 
   s->save_nblockMAX   = nblockMAX;
626
 
   s->save_nblock      = nblock;
627
 
   s->save_es          = es;
628
 
   s->save_N           = N;
629
 
   s->save_curr        = curr;
630
 
   s->save_zt          = zt;
631
 
   s->save_zn          = zn;
632
 
   s->save_zvec        = zvec;
633
 
   s->save_zj          = zj;
634
 
   s->save_gSel        = gSel;
635
 
   s->save_gMinlen     = gMinlen;
636
 
   s->save_gLimit      = gLimit;
637
 
   s->save_gBase       = gBase;
638
 
   s->save_gPerm       = gPerm;
639
 
 
640
 
   return retVal;   
641
 
}
642
 
 
643
 
 
644
 
/*-------------------------------------------------------------*/
645
 
/*--- end                                      decompress.c ---*/
646
 
/*-------------------------------------------------------------*/