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
makeMaps_d(DState * s)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 /*---------------------------------------------------*/
BZ2_decompress(DState * s)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 /*-------------------------------------------------------------*/
663