PageRenderTime 55ms CodeModel.GetById 16ms app.highlight 33ms RepoModel.GetById 1ms app.codeStats 0ms

/contrib/bzip2/decompress.c

https://bitbucket.org/freebsd/freebsd-head/
C | 646 lines | 505 code | 83 blank | 58 comment | 160 complexity | bde11e869774425cc75c29e20f05fb64 MD5 | raw file
  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/*---------------------------------------------------*/
 26static
 27void 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/*---------------------------------------------------*/
106Int32 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/*-------------------------------------------------------------*/