← Back to branch summary

~efargaspro/+junk/codeblocks-16.01-release

« back to all changes in this revision

Viewing changes to src/plugins/contrib/SpellChecker/wxspellchecker/tools/bzipstream/bzip/decompress.c

  • Committer: damienlmoore at gmail
  • Date: 2016-02-02 02:43:22 UTC
  • Revision ID: damienlmoore@gmail.com-20160202024322-yql5qmtbwdyamdwd
Code::Blocks 16.01

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/plugins/contrib/SpellChecker/wxspellchecker/tools/bzipstream/bzip/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
/*-------------------------------------------------------------*/