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