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