op public repos

Blob

Date:: Wed Apr 14 20:09:21 2004 UTC
Message:: add gzip, bzip2 '
Actions:: History | Blame | Raw File
1 
2 /*-------------------------------------------------------------*/
3 /*--- Decompression machinery                               ---*/
4 /*---                                          decompress.c ---*/
5 /*-------------------------------------------------------------*/
6 
7 /*--
8   This file is a part of bzip2 and/or libbzip2, a program and
9   library for lossless, block-sorting data compression.
10 
11   Copyright (C) 1996-2000 Julian R Seward.  All rights reserved.
12 
13   Redistribution and use in source and binary forms, with or without
14   modification, are permitted provided that the following conditions
15   are met:
16 
17   1. Redistributions of source code must retain the above copyright
18      notice, this list of conditions and the following disclaimer.
19 
20   2. The origin of this software must not be misrepresented; you must 
21      not claim that you wrote the original software.  If you use this 
22      software in a product, an acknowledgment in the product 
23      documentation would be appreciated but is not required.
24 
25   3. Altered source versions must be plainly marked as such, and must
26      not be misrepresented as being the original software.
27 
28   4. The name of the author may not be used to endorse or promote 
29      products derived from this software without specific prior written 
30      permission.
31 
32   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
33   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
34   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
35   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
36   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
37   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
38   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
39   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
40   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
41   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
42   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
43 
44   Julian Seward, Cambridge, UK.
45   jseward@acm.org
46   bzip2/libbzip2 version 1.0 of 21 March 2000
47 
48   This program is based on (at least) the work of:
49      Mike Burrows
50      David Wheeler
51      Peter Fenwick
52      Alistair Moffat
53      Radford Neal
54      Ian H. Witten
55      Robert Sedgewick
56      Jon L. Bentley
57 
58   For more information on these sources, see the manual.
59 --*/
60 
61 
62 #include "os.h"
63 #include "bzlib.h"
64 #include "bzlib_private.h"
65 
66 
67 /*---------------------------------------------------*/
68 static
69 void makeMaps_d ( DState* s )
70 {
71    Int32 i;
72    s->nInUse = 0;
73    for (i = 0; i < 256; i++)
74       if (s->inUse[i]) {
75          s->seqToUnseq[s->nInUse] = i;
76          s->nInUse++;
77       }
78 }
79 
80 
81 /*---------------------------------------------------*/
82 #define RETURN(rrr)                               \
83    { retVal = rrr; goto save_state_and_return; };
84 
85 #define GET_BITS(lll,vvv,nnn)                     \
86    case lll: s->state = lll;                      \
87    while (True) {                                 \
88       if (s->bsLive >= nnn) {                     \
89          UInt32 v;                                \
90          v = (s->bsBuff >>                        \
91              (s->bsLive-nnn)) & ((1 << nnn)-1);   \
92          s->bsLive -= nnn;                        \
93          vvv = v;                                 \
94          break;                                   \
95       }                                           \
96       if (s->strm->avail_in == 0) RETURN(BZ_OK);  \
97       s->bsBuff                                   \
98          = (s->bsBuff << 8) |                     \
99            ((UInt32)                              \
100               (*((UChar*)(s->strm->next_in))));   \
101       s->bsLive += 8;                             \
102       s->strm->next_in++;                         \
103       s->strm->avail_in--;                        \
104       s->strm->total_in_lo32++;                   \
105       if (s->strm->total_in_lo32 == 0)            \
106          s->strm->total_in_hi32++;                \
107    }
108 
109 #define GET_UCHAR(lll,uuu)                        \
110    GET_BITS(lll,uuu,8)
111 
112 #define GET_BIT(lll,uuu)                          \
113    GET_BITS(lll,uuu,1)
114 
115 /*---------------------------------------------------*/
116 #define GET_MTF_VAL(label1,label2,lval)           \
117 {                                                 \
118    if (groupPos == 0) {                           \
119       groupNo++;                                  \
120       if (groupNo >= nSelectors)                  \
121          RETURN(BZ_DATA_ERROR);                   \
122       groupPos = BZ_G_SIZE;                       \
123       gSel = s->selector[groupNo];                \
124       gMinlen = s->minLens[gSel];                 \
125       gLimit = &(s->limit[gSel][0]);              \
126       gPerm = &(s->perm[gSel][0]);                \
127       gBase = &(s->base[gSel][0]);                \
128    }                                              \
129    groupPos--;                                    \
130    zn = gMinlen;                                  \
131    GET_BITS(label1, zvec, zn);                    \
132    while (1) {                                    \
133       if (zn > 20 /* the longest code */)         \
134          RETURN(BZ_DATA_ERROR);                   \
135       if (zvec <= gLimit[zn]) break;              \
136       zn++;                                       \
137       GET_BIT(label2, zj);                        \
138       zvec = (zvec << 1) | zj;                    \
139    };                                             \
140    if (zvec - gBase[zn] < 0                       \
141        || zvec - gBase[zn] >= BZ_MAX_ALPHA_SIZE)  \
142       RETURN(BZ_DATA_ERROR);                      \
143    lval = gPerm[zvec - gBase[zn]];                \
144 }
145 
146 
147 /*---------------------------------------------------*/
148 Int32 BZ2_decompress ( DState* s )
149 {
150    UChar      uc;
151    Int32      retVal;
152    Int32      minLen, maxLen;
153    bz_stream* strm = s->strm;
154 
155    /* stuff that needs to be saved/restored */
156    Int32  i;
157    Int32  j;
158    Int32  t;
159    Int32  alphaSize;
160    Int32  nGroups;
161    Int32  nSelectors;
162    Int32  EOB;
163    Int32  groupNo;
164    Int32  groupPos;
165    Int32  nextSym;
166    Int32  nblockMAX;
167    Int32  nblock;
168    Int32  es;
169    Int32  N;
170    Int32  curr;
171    Int32  zt;
172    Int32  zn; 
173    Int32  zvec;
174    Int32  zj;
175    Int32  gSel;
176    Int32  gMinlen;
177    Int32* gLimit;
178    Int32* gBase;
179    Int32* gPerm;
180 
181    if (s->state == BZ_X_MAGIC_1) {
182       /*initialise the save area*/
183       s->save_i           = 0;
184       s->save_j           = 0;
185       s->save_t           = 0;
186       s->save_alphaSize   = 0;
187       s->save_nGroups     = 0;
188       s->save_nSelectors  = 0;
189       s->save_EOB         = 0;
190       s->save_groupNo     = 0;
191       s->save_groupPos    = 0;
192       s->save_nextSym     = 0;
193       s->save_nblockMAX   = 0;
194       s->save_nblock      = 0;
195       s->save_es          = 0;
196       s->save_N           = 0;
197       s->save_curr        = 0;
198       s->save_zt          = 0;
199       s->save_zn          = 0;
200       s->save_zvec        = 0;
201       s->save_zj          = 0;
202       s->save_gSel        = 0;
203       s->save_gMinlen     = 0;
204       s->save_gLimit      = NULL;
205       s->save_gBase       = NULL;
206       s->save_gPerm       = NULL;
207    }
208 
209    /*restore from the save area*/
210    i           = s->save_i;
211    j           = s->save_j;
212    t           = s->save_t;
213    alphaSize   = s->save_alphaSize;
214    nGroups     = s->save_nGroups;
215    nSelectors  = s->save_nSelectors;
216    EOB         = s->save_EOB;
217    groupNo     = s->save_groupNo;
218    groupPos    = s->save_groupPos;
219    nextSym     = s->save_nextSym;
220    nblockMAX   = s->save_nblockMAX;
221    nblock      = s->save_nblock;
222    es          = s->save_es;
223    N           = s->save_N;
224    curr        = s->save_curr;
225    zt          = s->save_zt;
226    zn          = s->save_zn; 
227    zvec        = s->save_zvec;
228    zj          = s->save_zj;
229    gSel        = s->save_gSel;
230    gMinlen     = s->save_gMinlen;
231    gLimit      = s->save_gLimit;
232    gBase       = s->save_gBase;
233    gPerm       = s->save_gPerm;
234 
235    retVal = BZ_OK;
236 
237    switch (s->state) {
238 
239       GET_UCHAR(BZ_X_MAGIC_1, uc);
240       if (uc != 'B') RETURN(BZ_DATA_ERROR_MAGIC);
241 
242       GET_UCHAR(BZ_X_MAGIC_2, uc);
243       if (uc != 'Z') RETURN(BZ_DATA_ERROR_MAGIC);
244 
245       GET_UCHAR(BZ_X_MAGIC_3, uc)
246       if (uc != 'h') RETURN(BZ_DATA_ERROR_MAGIC);
247 
248       GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
249       if (s->blockSize100k < '1' || 
250           s->blockSize100k > '9') RETURN(BZ_DATA_ERROR_MAGIC);
251       s->blockSize100k -= '0';
252 
253       if (s->smallDecompress) {
254          s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
255          s->ll4  = BZALLOC( 
256                       ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar) 
257                    );
258          if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
259       } else {
260          s->tt  = BZALLOC( s->blockSize100k * 100000 * sizeof(Int32) );
261          if (s->tt == NULL) RETURN(BZ_MEM_ERROR);
262       }
263 
264       GET_UCHAR(BZ_X_BLKHDR_1, uc);
265 
266       if (uc == 0x17) goto endhdr_2;
267       if (uc != 0x31) RETURN(BZ_DATA_ERROR);
268       GET_UCHAR(BZ_X_BLKHDR_2, uc);
269       if (uc != 0x41) RETURN(BZ_DATA_ERROR);
270       GET_UCHAR(BZ_X_BLKHDR_3, uc);
271       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
272       GET_UCHAR(BZ_X_BLKHDR_4, uc);
273       if (uc != 0x26) RETURN(BZ_DATA_ERROR);
274       GET_UCHAR(BZ_X_BLKHDR_5, uc);
275       if (uc != 0x53) RETURN(BZ_DATA_ERROR);
276       GET_UCHAR(BZ_X_BLKHDR_6, uc);
277       if (uc != 0x59) RETURN(BZ_DATA_ERROR);
278 
279       s->currBlockNo++;
280       if (s->verbosity >= 2)
281          VPrintf1 ( "\n    [%d: huff+mtf ", s->currBlockNo );
282  
283       s->storedBlockCRC = 0;
284       GET_UCHAR(BZ_X_BCRC_1, uc);
285       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
286       GET_UCHAR(BZ_X_BCRC_2, uc);
287       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
288       GET_UCHAR(BZ_X_BCRC_3, uc);
289       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
290       GET_UCHAR(BZ_X_BCRC_4, uc);
291       s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
292 
293       GET_BITS(BZ_X_RANDBIT, s->blockRandomised, 1);
294 
295       s->origPtr = 0;
296       GET_UCHAR(BZ_X_ORIGPTR_1, uc);
297       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
298       GET_UCHAR(BZ_X_ORIGPTR_2, uc);
299       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
300       GET_UCHAR(BZ_X_ORIGPTR_3, uc);
301       s->origPtr = (s->origPtr << 8) | ((Int32)uc);
302 
303       if (s->origPtr < 0)
304          RETURN(BZ_DATA_ERROR);
305       if (s->origPtr > 10 + 100000*s->blockSize100k) 
306          RETURN(BZ_DATA_ERROR);
307 
308       /*--- Receive the mapping table ---*/
309       for (i = 0; i < 16; i++) {
310          GET_BIT(BZ_X_MAPPING_1, uc);
311          if (uc == 1) 
312             s->inUse16[i] = True; else 
313             s->inUse16[i] = False;
314       }
315 
316       for (i = 0; i < 256; i++) s->inUse[i] = False;
317 
318       for (i = 0; i < 16; i++)
319          if (s->inUse16[i])
320             for (j = 0; j < 16; j++) {
321                GET_BIT(BZ_X_MAPPING_2, uc);
322                if (uc == 1) s->inUse[i * 16 + j] = True;
323             }
324       makeMaps_d ( s );
325       if (s->nInUse == 0) RETURN(BZ_DATA_ERROR);
326       alphaSize = s->nInUse+2;
327 
328       /*--- Now the selectors ---*/
329       GET_BITS(BZ_X_SELECTOR_1, nGroups, 3);
330       if (nGroups < 2 || nGroups > 6) RETURN(BZ_DATA_ERROR);
331       GET_BITS(BZ_X_SELECTOR_2, nSelectors, 15);
332       if (nSelectors < 1) RETURN(BZ_DATA_ERROR);
333       for (i = 0; i < nSelectors; i++) {
334          j = 0;
335          while (True) {
336             GET_BIT(BZ_X_SELECTOR_3, uc);
337             if (uc == 0) break;
338             j++;
339             if (j >= nGroups) RETURN(BZ_DATA_ERROR);
340          }
341          s->selectorMtf[i] = j;
342       }
343 
344       /*--- Undo the MTF values for the selectors. ---*/
345       {
346          UChar pos[BZ_N_GROUPS], tmp, v;
347          for (v = 0; v < nGroups; v++) pos[v] = v;
348    
349          for (i = 0; i < nSelectors; i++) {
350             v = s->selectorMtf[i];
351             tmp = pos[v];
352             while (v > 0) { pos[v] = pos[v-1]; v--; }
353             pos[0] = tmp;
354             s->selector[i] = tmp;
355          }
356       }
357 
358       /*--- Now the coding tables ---*/
359       for (t = 0; t < nGroups; t++) {
360          GET_BITS(BZ_X_CODING_1, curr, 5);
361          for (i = 0; i < alphaSize; i++) {
362             while (True) {
363                if (curr < 1 || curr > 20) RETURN(BZ_DATA_ERROR);
364                GET_BIT(BZ_X_CODING_2, uc);
365                if (uc == 0) break;
366                GET_BIT(BZ_X_CODING_3, uc);
367                if (uc == 0) curr++; else curr--;
368             }
369             s->len[t][i] = curr;
370          }
371       }
372 
373       /*--- Create the Huffman decoding tables ---*/
374       for (t = 0; t < nGroups; t++) {
375          minLen = 32;
376          maxLen = 0;
377          for (i = 0; i < alphaSize; i++) {
378             if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
379             if (s->len[t][i] < minLen) minLen = s->len[t][i];
380          }
381          BZ2_hbCreateDecodeTables ( 
382             &(s->limit[t][0]), 
383             &(s->base[t][0]), 
384             &(s->perm[t][0]), 
385             &(s->len[t][0]),
386             minLen, maxLen, alphaSize
387          );
388          s->minLens[t] = minLen;
389       }
390 
391       /*--- Now the MTF values ---*/
392 
393       EOB      = s->nInUse+1;
394       nblockMAX = 100000 * s->blockSize100k;
395       groupNo  = -1;
396       groupPos = 0;
397 
398       for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
399 
400       /*-- MTF init --*/
401       {
402          Int32 ii, jj, kk;
403          kk = MTFA_SIZE-1;
404          for (ii = 256 / MTFL_SIZE - 1; ii >= 0; ii--) {
405             for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
406                s->mtfa[kk] = (UChar)(ii * MTFL_SIZE + jj);
407                kk--;
408             }
409             s->mtfbase[ii] = kk + 1;
410          }
411       }
412       /*-- end MTF init --*/
413 
414       nblock = 0;
415       GET_MTF_VAL(BZ_X_MTF_1, BZ_X_MTF_2, nextSym);
416 
417       while (True) {
418 
419          if (nextSym == EOB) break;
420 
421          if (nextSym == BZ_RUNA || nextSym == BZ_RUNB) {
422 
423             es = -1;
424             N = 1;
425             do {
426                if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
427                if (nextSym == BZ_RUNB) es = es + (1+1) * N;
428                N = N * 2;
429                GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
430             }
431                while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
432 
433             es++;
434             uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
435             s->unzftab[uc] += es;
436 
437             if (s->smallDecompress)
438                while (es > 0) {
439                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
440                   s->ll16[nblock] = (UInt16)uc;
441                   nblock++;
442                   es--;
443                }
444             else
445                while (es > 0) {
446                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
447                   s->tt[nblock] = (UInt32)uc;
448                   nblock++;
449                   es--;
450                };
451 
452             continue;
453 
454          } else {
455 
456             if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
457 
458             /*-- uc = MTF ( nextSym-1 ) --*/
459             {
460                Int32 ii, jj, kk, pp, lno, off;
461                UInt32 nn;
462                nn = (UInt32)(nextSym - 1);
463 
464                if (nn < MTFL_SIZE) {
465                   /* avoid general-case expense */
466                   pp = s->mtfbase[0];
467                   uc = s->mtfa[pp+nn];
468                   while (nn > 3) {
469                      Int32 z = pp+nn;
470                      s->mtfa[(z)  ] = s->mtfa[(z)-1];
471                      s->mtfa[(z)-1] = s->mtfa[(z)-2];
472                      s->mtfa[(z)-2] = s->mtfa[(z)-3];
473                      s->mtfa[(z)-3] = s->mtfa[(z)-4];
474                      nn -= 4;
475                   }
476                   while (nn > 0) { 
477                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--; 
478                   };
479                   s->mtfa[pp] = uc;
480                } else { 
481                   /* general case */
482                   lno = nn / MTFL_SIZE;
483                   off = nn % MTFL_SIZE;
484                   pp = s->mtfbase[lno] + off;
485                   uc = s->mtfa[pp];
486                   while (pp > s->mtfbase[lno]) { 
487                      s->mtfa[pp] = s->mtfa[pp-1]; pp--; 
488                   };
489                   s->mtfbase[lno]++;
490                   while (lno > 0) {
491                      s->mtfbase[lno]--;
492                      s->mtfa[s->mtfbase[lno]] 
493                         = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
494                      lno--;
495                   }
496                   s->mtfbase[0]--;
497                   s->mtfa[s->mtfbase[0]] = uc;
498                   if (s->mtfbase[0] == 0) {
499                      kk = MTFA_SIZE-1;
500                      for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
501                         for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
502                            s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
503                            kk--;
504                         }
505                         s->mtfbase[ii] = kk + 1;
506                      }
507                   }
508                }
509             }
510             /*-- end uc = MTF ( nextSym-1 ) --*/
511 
512             s->unzftab[s->seqToUnseq[uc]]++;
513             if (s->smallDecompress)
514                s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
515                s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
516             nblock++;
517 
518             GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
519             continue;
520          }
521       }
522 
523       /* Now we know what nblock is, we can do a better sanity
524          check on s->origPtr.
525       */
526       if (s->origPtr < 0 || s->origPtr >= nblock)
527          RETURN(BZ_DATA_ERROR);
528 
529       s->state_out_len = 0;
530       s->state_out_ch  = 0;
531       BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
532       s->state = BZ_X_OUTPUT;
533       if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
534 
535       /*-- Set up cftab to facilitate generation of T^(-1) --*/
536       s->cftab[0] = 0;
537       for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
538       for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
539 
540       if (s->smallDecompress) {
541 
542          /*-- Make a copy of cftab, used in generation of T --*/
543          for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
544 
545          /*-- compute the T vector --*/
546          for (i = 0; i < nblock; i++) {
547             uc = (UChar)(s->ll16[i]);
548             SET_LL(i, s->cftabCopy[uc]);
549             s->cftabCopy[uc]++;
550          }
551 
552          /*-- Compute T^(-1) by pointer reversal on T --*/
553          i = s->origPtr;
554          j = GET_LL(i);
555          do {
556             Int32 tmp = GET_LL(j);
557             SET_LL(j, i);
558             i = j;
559             j = tmp;
560          }
561             while (i != s->origPtr);
562 
563          s->tPos = s->origPtr;
564          s->nblock_used = 0;
565          if (s->blockRandomised) {
566             BZ_RAND_INIT_MASK;
567             BZ_GET_SMALL(s->k0); s->nblock_used++;
568             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
569          } else {
570             BZ_GET_SMALL(s->k0); s->nblock_used++;
571          }
572 
573       } else {
574 
575          /*-- compute the T^(-1) vector --*/
576          for (i = 0; i < nblock; i++) {
577             uc = (UChar)(s->tt[i] & 0xff);
578             s->tt[s->cftab[uc]] |= (i << 8);
579             s->cftab[uc]++;
580          }
581 
582          s->tPos = s->tt[s->origPtr] >> 8;
583          s->nblock_used = 0;
584          if (s->blockRandomised) {
585             BZ_RAND_INIT_MASK;
586             BZ_GET_FAST(s->k0); s->nblock_used++;
587             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK; 
588          } else {
589             BZ_GET_FAST(s->k0); s->nblock_used++;
590          }
591 
592       }
593 
594       RETURN(BZ_OK);
595 
596 
597 
598     endhdr_2:
599 
600       GET_UCHAR(BZ_X_ENDHDR_2, uc);
601       if (uc != 0x72) RETURN(BZ_DATA_ERROR);
602       GET_UCHAR(BZ_X_ENDHDR_3, uc);
603       if (uc != 0x45) RETURN(BZ_DATA_ERROR);
604       GET_UCHAR(BZ_X_ENDHDR_4, uc);
605       if (uc != 0x38) RETURN(BZ_DATA_ERROR);
606       GET_UCHAR(BZ_X_ENDHDR_5, uc);
607       if (uc != 0x50) RETURN(BZ_DATA_ERROR);
608       GET_UCHAR(BZ_X_ENDHDR_6, uc);
609       if (uc != 0x90) RETURN(BZ_DATA_ERROR);
610 
611       s->storedCombinedCRC = 0;
612       GET_UCHAR(BZ_X_CCRC_1, uc);
613       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
614       GET_UCHAR(BZ_X_CCRC_2, uc);
615       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
616       GET_UCHAR(BZ_X_CCRC_3, uc);
617       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
618       GET_UCHAR(BZ_X_CCRC_4, uc);
619       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
620 
621       s->state = BZ_X_IDLE;
622       RETURN(BZ_STREAM_END);
623 
624       default: AssertH ( False, 4001 );
625    }
626 
627    AssertH ( False, 4002 );
628 
629    save_state_and_return:
630 
631    s->save_i           = i;
632    s->save_j           = j;
633    s->save_t           = t;
634    s->save_alphaSize   = alphaSize;
635    s->save_nGroups     = nGroups;
636    s->save_nSelectors  = nSelectors;
637    s->save_EOB         = EOB;
638    s->save_groupNo     = groupNo;
639    s->save_groupPos    = groupPos;
640    s->save_nextSym     = nextSym;
641    s->save_nblockMAX   = nblockMAX;
642    s->save_nblock      = nblock;
643    s->save_es          = es;
644    s->save_N           = N;
645    s->save_curr        = curr;
646    s->save_zt          = zt;
647    s->save_zn          = zn;
648    s->save_zvec        = zvec;
649    s->save_zj          = zj;
650    s->save_gSel        = gSel;
651    s->save_gMinlen     = gMinlen;
652    s->save_gLimit      = gLimit;
653    s->save_gBase       = gBase;
654    s->save_gPerm       = gPerm;
655 
656    return retVal;   
657 }
658 
659 
660 /*-------------------------------------------------------------*/
661 /*--- end                                      decompress.c ---*/
662 /*-------------------------------------------------------------*/