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.5 of 10 December 2007
  12    Copyright (C) 1996-2007 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                if (nextSym == BZ_RUNA) es = es + (0+1) * N; else
 385                if (nextSym == BZ_RUNB) es = es + (1+1) * N;
 386                N = N * 2;
 387                GET_MTF_VAL(BZ_X_MTF_3, BZ_X_MTF_4, nextSym);
 388             }
 389                while (nextSym == BZ_RUNA || nextSym == BZ_RUNB);
 390
 391             es++;
 392             uc = s->seqToUnseq[ s->mtfa[s->mtfbase[0]] ];
 393             s->unzftab[uc] += es;
 394
 395             if (s->smallDecompress)
 396                while (es > 0) {
 397                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
 398                   s->ll16[nblock] = (UInt16)uc;
 399                   nblock++;
 400                   es--;
 401                }
 402             else
 403                while (es > 0) {
 404                   if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
 405                   s->tt[nblock] = (UInt32)uc;
 406                   nblock++;
 407                   es--;
 408                };
 409
 410             continue;
 411
 412          } else {
 413
 414             if (nblock >= nblockMAX) RETURN(BZ_DATA_ERROR);
 415
 416             /*-- uc = MTF ( nextSym-1 ) --*/
 417             {
 418                Int32 ii, jj, kk, pp, lno, off;
 419                UInt32 nn;
 420                nn = (UInt32)(nextSym - 1);
 421
 422                if (nn < MTFL_SIZE) {
 423                   /* avoid general-case expense */
 424                   pp = s->mtfbase[0];
 425                   uc = s->mtfa[pp+nn];
 426                   while (nn > 3) {
 427                      Int32 z = pp+nn;
 428                      s->mtfa[(z)  ] = s->mtfa[(z)-1];
 429                      s->mtfa[(z)-1] = s->mtfa[(z)-2];
 430                      s->mtfa[(z)-2] = s->mtfa[(z)-3];
 431                      s->mtfa[(z)-3] = s->mtfa[(z)-4];
 432                      nn -= 4;
 433                   }
 434                   while (nn > 0) {
 435                      s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
 436                   };
 437                   s->mtfa[pp] = uc;
 438                } else {
 439                   /* general case */
 440                   lno = nn / MTFL_SIZE;
 441                   off = nn % MTFL_SIZE;
 442                   pp = s->mtfbase[lno] + off;
 443                   uc = s->mtfa[pp];
 444                   while (pp > s->mtfbase[lno]) {
 445                      s->mtfa[pp] = s->mtfa[pp-1]; pp--;
 446                   };
 447                   s->mtfbase[lno]++;
 448                   while (lno > 0) {
 449                      s->mtfbase[lno]--;
 450                      s->mtfa[s->mtfbase[lno]]
 451                         = s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
 452                      lno--;
 453                   }
 454                   s->mtfbase[0]--;
 455                   s->mtfa[s->mtfbase[0]] = uc;
 456                   if (s->mtfbase[0] == 0) {
 457                      kk = MTFA_SIZE-1;
 458                      for (ii = 256 / MTFL_SIZE-1; ii >= 0; ii--) {
 459                         for (jj = MTFL_SIZE-1; jj >= 0; jj--) {
 460                            s->mtfa[kk] = s->mtfa[s->mtfbase[ii] + jj];
 461                            kk--;
 462                         }
 463                         s->mtfbase[ii] = kk + 1;
 464                      }
 465                   }
 466                }
 467             }
 468             /*-- end uc = MTF ( nextSym-1 ) --*/
 469
 470             s->unzftab[s->seqToUnseq[uc]]++;
 471             if (s->smallDecompress)
 472                s->ll16[nblock] = (UInt16)(s->seqToUnseq[uc]); else
 473                s->tt[nblock]   = (UInt32)(s->seqToUnseq[uc]);
 474             nblock++;
 475
 476             GET_MTF_VAL(BZ_X_MTF_5, BZ_X_MTF_6, nextSym);
 477             continue;
 478          }
 479       }
 480
 481       /* Now we know what nblock is, we can do a better sanity
 482          check on s->origPtr.
 483       */
 484       if (s->origPtr < 0 || s->origPtr >= nblock)
 485          RETURN(BZ_DATA_ERROR);
 486
 487       /*-- Set up cftab to facilitate generation of T^(-1) --*/
 488       s->cftab[0] = 0;
 489       for (i = 1; i <= 256; i++) s->cftab[i] = s->unzftab[i-1];
 490       for (i = 1; i <= 256; i++) s->cftab[i] += s->cftab[i-1];
 491       for (i = 0; i <= 256; i++) {
 492          if (s->cftab[i] < 0 || s->cftab[i] > nblock) {
 493             /* s->cftab[i] can legitimately be == nblock */
 494             RETURN(BZ_DATA_ERROR);
 495          }
 496       }
 497
 498       s->state_out_len = 0;
 499       s->state_out_ch  = 0;
 500       BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
 501       s->state = BZ_X_OUTPUT;
 502       if (s->verbosity >= 2) VPrintf0 ( "rt+rld" );
 503
 504       if (s->smallDecompress) {
 505
 506          /*-- Make a copy of cftab, used in generation of T --*/
 507          for (i = 0; i <= 256; i++) s->cftabCopy[i] = s->cftab[i];
 508
 509          /*-- compute the T vector --*/
 510          for (i = 0; i < nblock; i++) {
 511             uc = (UChar)(s->ll16[i]);
 512             SET_LL(i, s->cftabCopy[uc]);
 513             s->cftabCopy[uc]++;
 514          }
 515
 516          /*-- Compute T^(-1) by pointer reversal on T --*/
 517          i = s->origPtr;
 518          j = GET_LL(i);
 519          do {
 520             Int32 tmp = GET_LL(j);
 521             SET_LL(j, i);
 522             i = j;
 523             j = tmp;
 524          }
 525             while (i != s->origPtr);
 526
 527          s->tPos = s->origPtr;
 528          s->nblock_used = 0;
 529          if (s->blockRandomised) {
 530             BZ_RAND_INIT_MASK;
 531             BZ_GET_SMALL(s->k0); s->nblock_used++;
 532             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
 533          } else {
 534             BZ_GET_SMALL(s->k0); s->nblock_used++;
 535          }
 536
 537       } else {
 538
 539          /*-- compute the T^(-1) vector --*/
 540          for (i = 0; i < nblock; i++) {
 541             uc = (UChar)(s->tt[i] & 0xff);
 542             s->tt[s->cftab[uc]] |= (i << 8);
 543             s->cftab[uc]++;
 544          }
 545
 546          s->tPos = s->tt[s->origPtr] >> 8;
 547          s->nblock_used = 0;
 548          if (s->blockRandomised) {
 549             BZ_RAND_INIT_MASK;
 550             BZ_GET_FAST(s->k0); s->nblock_used++;
 551             BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
 552          } else {
 553             BZ_GET_FAST(s->k0); s->nblock_used++;
 554          }
 555
 556       }
 557
 558       RETURN(BZ_OK);
 559
 560
 561
 562     endhdr_2:
 563
 564       GET_UCHAR(BZ_X_ENDHDR_2, uc);
 565       if (uc != 0x72) RETURN(BZ_DATA_ERROR);
 566       GET_UCHAR(BZ_X_ENDHDR_3, uc);
 567       if (uc != 0x45) RETURN(BZ_DATA_ERROR);
 568       GET_UCHAR(BZ_X_ENDHDR_4, uc);
 569       if (uc != 0x38) RETURN(BZ_DATA_ERROR);
 570       GET_UCHAR(BZ_X_ENDHDR_5, uc);
 571       if (uc != 0x50) RETURN(BZ_DATA_ERROR);
 572       GET_UCHAR(BZ_X_ENDHDR_6, uc);
 573       if (uc != 0x90) RETURN(BZ_DATA_ERROR);
 574
 575       s->storedCombinedCRC = 0;
 576       GET_UCHAR(BZ_X_CCRC_1, uc);
 577       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
 578       GET_UCHAR(BZ_X_CCRC_2, uc);
 579       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
 580       GET_UCHAR(BZ_X_CCRC_3, uc);
 581       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
 582       GET_UCHAR(BZ_X_CCRC_4, uc);
 583       s->storedCombinedCRC = (s->storedCombinedCRC << 8) | ((UInt32)uc);
 584
 585       s->state = BZ_X_IDLE;
 586       RETURN(BZ_STREAM_END);
 587
 588       default: AssertH ( False, 4001 );
 589    }
 590
 591    AssertH ( False, 4002 );
 592
 593    save_state_and_return:
 594
 595    s->save_i           = i;
 596    s->save_j           = j;
 597    s->save_t           = t;
 598    s->save_alphaSize   = alphaSize;
 599    s->save_nGroups     = nGroups;
 600    s->save_nSelectors  = nSelectors;
 601    s->save_EOB         = EOB;
 602    s->save_groupNo     = groupNo;
 603    s->save_groupPos    = groupPos;
 604    s->save_nextSym     = nextSym;
 605    s->save_nblockMAX   = nblockMAX;
 606    s->save_nblock      = nblock;
 607    s->save_es          = es;
 608    s->save_N           = N;
 609    s->save_curr        = curr;
 610    s->save_zt          = zt;
 611    s->save_zn          = zn;
 612    s->save_zvec        = zvec;
 613    s->save_zj          = zj;
 614    s->save_gSel        = gSel;
 615    s->save_gMinlen     = gMinlen;
 616    s->save_gLimit      = gLimit;
 617    s->save_gBase       = gBase;
 618    s->save_gPerm       = gPerm;
 619
 620    return retVal;
 621 }
 622
 623
 624 /*-------------------------------------------------------------*/
 625 /*--- end                                      decompress.c ---*/
 626 /*-------------------------------------------------------------*/