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/*---------------------------------------------------*/ 26static 27void 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/*---------------------------------------------------*/ 106Int32 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/*-------------------------------------------------------------*/ 647