/*-------------------------------------------------------------*/
/*--- Decompression machinery ---*/
/*--- decompress.c ---*/
/*-------------------------------------------------------------*/
/* ------------------------------------------------------------------
lossless, block-sorting data compression.
Copyright (C) 1996-2010 Julian Seward <jseward@bzip.org>
Please read the WARNING, DISCLAIMER and PATENTS sections in the
README file.
This program is released under the terms of the license contained
in the file LICENSE.
------------------------------------------------------------------ */
#include "bzlib_private.h"
/*---------------------------------------------------*/
static
{
Int32 i;
s->nInUse = 0;
for (i = 0; i < 256; i++)
if (s->inUse[i]) {
s->seqToUnseq[s->nInUse] = i;
s->nInUse++;
}
}
/*---------------------------------------------------*/
while (True) { \
UInt32 v; \
v = (s->bsBuff >> \
vvv = v; \
break; \
} \
s->bsBuff \
= (s->bsBuff << 8) | \
((UInt32) \
s->bsLive += 8; \
s->strm->total_in_lo32++; \
if (s->strm->total_in_lo32 == 0) \
s->strm->total_in_hi32++; \
}
/*---------------------------------------------------*/
{ \
if (groupPos == 0) { \
groupNo++; \
if (groupNo >= nSelectors) \
RETURN(BZ_DATA_ERROR); \
} \
groupPos--; \
while (1) { \
RETURN(BZ_DATA_ERROR); \
zn++; \
}; \
RETURN(BZ_DATA_ERROR); \
}
/*---------------------------------------------------*/
{
Int32 i;
Int32 j;
Int32 t;
Int32 N;
if (s->state == BZ_X_MAGIC_1) {
/*initialise the save area*/
s->save_i = 0;
s->save_j = 0;
s->save_t = 0;
s->save_alphaSize = 0;
s->save_nGroups = 0;
s->save_nSelectors = 0;
s->save_EOB = 0;
s->save_groupNo = 0;
s->save_groupPos = 0;
s->save_nextSym = 0;
s->save_nblockMAX = 0;
s->save_nblock = 0;
s->save_es = 0;
s->save_N = 0;
s->save_curr = 0;
s->save_zt = 0;
s->save_zn = 0;
s->save_zvec = 0;
s->save_zj = 0;
s->save_gSel = 0;
s->save_gMinlen = 0;
s->save_gLimit = NULL;
s->save_gBase = NULL;
s->save_gPerm = NULL;
}
/*restore from the save area*/
i = s->save_i;
j = s->save_j;
t = s->save_t;
alphaSize = s->save_alphaSize;
nGroups = s->save_nGroups;
nSelectors = s->save_nSelectors;
groupNo = s->save_groupNo;
groupPos = s->save_groupPos;
nextSym = s->save_nextSym;
nblockMAX = s->save_nblockMAX;
nblock = s->save_nblock;
N = s->save_N;
gMinlen = s->save_gMinlen;
gLimit = s->save_gLimit;
gBase = s->save_gBase;
gPerm = s->save_gPerm;
switch (s->state) {
s->blockSize100k -= BZ_HDR_0;
if (s->smallDecompress) {
);
} else {
}
s->currBlockNo++;
if (s->verbosity >= 2)
s->storedBlockCRC = 0;
s->origPtr = 0;
if (s->origPtr < 0)
/*--- Receive the mapping table ---*/
for (i = 0; i < 16; i++) {
if (uc == 1)
}
for (i = 0; i < 16; i++)
if (s->inUse16[i])
for (j = 0; j < 16; j++) {
}
makeMaps_d ( s );
/*--- Now the selectors ---*/
for (i = 0; i < nSelectors; i++) {
j = 0;
while (True) {
if (uc == 0) break;
j++;
}
s->selectorMtf[i] = j;
}
/*--- Undo the MTF values for the selectors. ---*/
{
for (i = 0; i < nSelectors; i++) {
v = s->selectorMtf[i];
}
}
/*--- Now the coding tables ---*/
for (t = 0; t < nGroups; t++) {
for (i = 0; i < alphaSize; i++) {
while (True) {
if (uc == 0) break;
}
}
}
/*--- Create the Huffman decoding tables ---*/
for (t = 0; t < nGroups; t++) {
minLen = 32;
maxLen = 0;
for (i = 0; i < alphaSize; i++) {
}
&(s->limit[t][0]),
&(s->base[t][0]),
&(s->perm[t][0]),
&(s->len[t][0]),
);
}
/*--- Now the MTF values ---*/
groupNo = -1;
groupPos = 0;
for (i = 0; i <= 255; i++) s->unzftab[i] = 0;
/*-- MTF init --*/
{
kk--;
}
}
}
/*-- end MTF init --*/
nblock = 0;
while (True) {
es = -1;
N = 1;
do {
/* Check that N doesn't get too big, so that es doesn't
go negative. The maximum value that can be
the initial RLE), viz, 900k, so bounding N at 2
million should guard against overflow without
rejecting any legitimate inputs. */
N = N * 2;
}
es++;
if (s->smallDecompress)
while (es > 0) {
nblock++;
es--;
}
else
while (es > 0) {
nblock++;
es--;
};
continue;
} else {
/*-- uc = MTF ( nextSym-1 ) --*/
{
/* avoid general-case expense */
while (nn > 3) {
nn -= 4;
}
while (nn > 0) {
};
} else {
/* general case */
};
while (lno > 0) {
lno--;
}
s->mtfbase[0]--;
if (s->mtfbase[0] == 0) {
kk--;
}
}
}
}
}
/*-- end uc = MTF ( nextSym-1 ) --*/
if (s->smallDecompress)
nblock++;
continue;
}
}
/* Now we know what nblock is, we can do a better sanity
check on s->origPtr.
*/
/*-- Set up cftab to facilitate generation of T^(-1) --*/
/* Check: unzftab entries in range. */
for (i = 0; i <= 255; i++) {
}
/* Actually generate cftab. */
s->cftab[0] = 0;
/* Check: cftab entries in range. */
for (i = 0; i <= 256; i++) {
/* s->cftab[i] can legitimately be == nblock */
}
}
/* Check: cftab entries non-descending. */
for (i = 1; i <= 256; i++) {
}
}
s->state_out_len = 0;
s->state_out_ch = 0;
BZ_INITIALISE_CRC ( s->calculatedBlockCRC );
s->state = BZ_X_OUTPUT;
if (s->smallDecompress) {
/*-- Make a copy of cftab, used in generation of T --*/
/*-- compute the T vector --*/
for (i = 0; i < nblock; i++) {
}
/*-- Compute T^(-1) by pointer reversal on T --*/
i = s->origPtr;
j = GET_LL(i);
do {
SET_LL(j, i);
i = j;
j = tmp;
}
while (i != s->origPtr);
s->nblock_used = 0;
if (s->blockRandomised) {
} else {
}
} else {
/*-- compute the T^(-1) vector --*/
for (i = 0; i < nblock; i++) {
}
s->nblock_used = 0;
if (s->blockRandomised) {
} else {
}
}
s->storedCombinedCRC = 0;
}
s->save_i = i;
s->save_j = j;
s->save_t = t;
s->save_alphaSize = alphaSize;
s->save_nGroups = nGroups;
s->save_nSelectors = nSelectors;
s->save_groupNo = groupNo;
s->save_groupPos = groupPos;
s->save_nextSym = nextSym;
s->save_nblockMAX = nblockMAX;
s->save_nblock = nblock;
s->save_N = N;
s->save_gMinlen = gMinlen;
s->save_gLimit = gLimit;
s->save_gBase = gBase;
s->save_gPerm = gPerm;
return retVal;
}
/*-------------------------------------------------------------*/
/*--- end decompress.c ---*/
/*-------------------------------------------------------------*/