xref: /titanic_41/usr/src/common/bzip2/decompress.c (revision b9071c34cb3102be3bbda85c57015ea13193aa6b)
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
makeMaps_d(DState * s)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 /*---------------------------------------------------*/
BZ2_decompress(DState * s)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 /*-------------------------------------------------------------*/
647