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