/* LzmaDec.c -- LZMA Decoder

#include "Precomp.h"

/* #include "CpuArch.h" */

#include "LzmaDec.h"

#define kNumBitModelTotalBits 11

#define kBitModelTotal (1 << kNumBitModelTotalBits)

#define RC_INIT_SIZE 5

#define kNumMoveBits 5

#define NORMALIZE if (range < kTopValue) { range <<= 8; code = (code << 8) | (*buf++); }

#define UPDATE_0(p) range = bound; *(p) = (CLzmaProb)(ttt + ((kBitModelTotal - ttt) >> kNumMoveBits));

#define UPDATE_1(p) range -= bound; code -= bound; *(p) = (CLzmaProb)(ttt - (ttt >> kNumMoveBits));

#define GET_BIT2(p, i, A0, A1) IF_BIT_0(p) \

#define TREE_GET_BIT(probs, i) { GET_BIT2(probs + i, i, ;, ;); }

#define REV_BIT(p, i, A0, A1) IF_BIT_0(p + i) \

#define REV_BIT_VAR( p, i, m) REV_BIT(p, i, i += m; m += m, m += m; i += m; )

#define REV_BIT_CONST(p, i, m) REV_BIT(p, i, i += m; , i += m * 2; )

#define REV_BIT_LAST( p, i, m) REV_BIT(p, i, i -= m , ; )

#define TREE_DECODE(probs, limit, i) \

{ i = 1; do { TREE_GET_BIT(probs, i); } while (i < limit); i -= limit; }

#define TREE_6_DECODE(probs, i) TREE_DECODE(probs, (1 << 6), i)

#else

#define TREE_6_DECODE(probs, i) \

{ i = 1; \

i -= 0x40; }

#endif

probLit = prob + (offs + bit + symbol); \

GET_BIT2(probLit, symbol, offs ^= bit; , ;)

#define NORMALIZE_CHECK if (range < kTopValue) { if (buf >= bufLimit) return DUMMY_INPUT_EOF; range <<= 8; code = (code << 8) | (*buf++); }

#define UPDATE_0_CHECK range = bound;

#define UPDATE_1_CHECK range -= bound; code -= bound;

#define GET_BIT2_CHECK(p, i, A0, A1) IF_BIT_0_CHECK(p) \

#define GET_BIT_CHECK(p, i) GET_BIT2_CHECK(p, i, ; , ;)

#define TREE_DECODE_CHECK(probs, limit, i) \

{ i = 1; do { GET_BIT_CHECK(probs + i, i) } while (i < limit); i -= limit; }

#define REV_BIT_CHECK(p, i, m) IF_BIT_0_CHECK(p + i) \

#define kNumPosBitsMax 4

*/

#else

static

{

CLzmaProb *probs = GET_PROBS;

unsigned state = (unsigned)p->state;

IF_BIT_0(prob)

{

unsigned symbol;

prob = probs + Literal;

if (processedPos != 0 || checkDicSize != 0)

prob += (UInt32)3 * ((((processedPos << 8) + dic[(dicPos == 0 ? dicBufSize : dicPos) - 1]) & lpMask) << lc);

{

state -= (state < 4) ? state : 3;

symbol = 1;

do { NORMAL_LITER_DEC } while (symbol < 0x100);

#else

NORMAL_LITER_DEC

unsigned offs = 0x100;

state -= (state < 10) ? 3 : 6;

symbol = 1;

do

{

unsigned bit;

}

{

prob = probs + IsRep + state;

IF_BIT_0(prob)

{

state += kNumStates;

prob = probs + LenCoder;

}

else

{

prob = probs + IsRepG0 + state;

IF_BIT_0(prob)

{

prob = probs + IsRep0Long + COMBINED_PS_STATE;

IF_BIT_0(prob)

{

// that case was checked before with kBadRepCode

// if (checkDicSize == 0 && processedPos == 0) { len = kMatchSpecLen_Error_Data + 1; break; }

state = state < kNumLitStates ? 9 : 11;

continue;

}

}

else

{

UInt32 distance;

prob = probs + IsRepG1 + state;

IF_BIT_0(prob)

{

distance = rep1;

}

else

{

prob = probs + IsRepG2 + state;

IF_BIT_0(prob)

{

distance = rep2;

}

else

{

distance = rep3;

rep3 = rep2;

}

prob = probs + RepLenCoder;

}

{

unsigned lim, offset;

CLzmaProb *probLen = prob + LenChoice;

IF_BIT_0(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE;

offset = 0;

lim = (1 << kLenNumLowBits);

}

else

{

probLen = prob + LenChoice2;

IF_BIT_0(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);

offset = kLenNumLowSymbols;

lim = (1 << kLenNumLowBits);

}

else

{

probLen = prob + LenHigh;

offset = kLenNumLowSymbols * 2;

lim = (1 << kLenNumHighBits);

}

}

len += offset;

}

#else

CLzmaProb *probLen = prob + LenChoice;

IF_BIT_0(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE;

len = 1;

len -= 8;

}

else

{

probLen = prob + LenChoice2;

IF_BIT_0(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);

len = 1;

}

else

{

probLen = prob + LenHigh;

len += kLenNumLowSymbols * 2;

}

}

UInt32 distance;

prob = probs + PosSlot +

((len < kNumLenToPosStates ? len : kNumLenToPosStates - 1) << kNumPosSlotBits);

if (distance >= kStartPosModelIndex)

{

unsigned posSlot = (unsigned)distance;

distance++;

do

{

}

while (--numDirectBits);

distance -= m;

distance <<= kNumAlignBits;

{

unsigned i = 1;

distance |= i;

}

if (distance == (UInt32)0xFFFFFFFF)

}

while (dicPos < limit && buf < bufLimit);

p->buf = buf;

p->range = range;

{

unsigned len = (unsigned)p->remainLen;

if (len == 0 /* || len >= kMatchSpecLenStart */)

(p->checkDicSize == p->prop.dicSize)

*/

{

if (p->checkDicSize == 0)

{

else

{

unsigned len;

prob = probs + IsRep + state;

IF_BIT_0_CHECK(prob)

{

state = 0;

prob = probs + LenCoder;

res = DUMMY_MATCH;

}

else

{

res = DUMMY_REP;

prob = probs + IsRepG0 + state;

IF_BIT_0_CHECK(prob)

{

prob = probs + IsRep0Long + COMBINED_PS_STATE;

IF_BIT_0_CHECK(prob)

{

break;

}

else

{

}

}

else

{

prob = probs + IsRepG1 + state;

IF_BIT_0_CHECK(prob)

{

}

else

{

prob = probs + IsRepG2 + state;

IF_BIT_0_CHECK(prob)

{

}

else

{

}

}

}

const CLzmaProb *probLen = prob + LenChoice;

IF_BIT_0_CHECK(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE;

offset = 0;

limit = 1 << kLenNumLowBits;

}

else

{

probLen = prob + LenChoice2;

IF_BIT_0_CHECK(probLen)

{

probLen = prob + LenLow + GET_LEN_STATE + (1 << kLenNumLowBits);

offset = kLenNumLowSymbols;

limit = 1 << kLenNumLowBits;

}

else

{

probLen = prob + LenHigh;

offset = kLenNumLowSymbols * 2;

limit = 1 << kLenNumHighBits;

}

}

len += offset;

}

prob = probs + PosSlot +

((len < kNumLenToPosStates - 1 ? len : kNumLenToPosStates - 1) <<

kNumPosSlotBits);

if (posSlot >= kStartPosModelIndex)

{

unsigned numDirectBits = ((posSlot >> 1) - 1);

unsigned m = 1;

do

{

}

while (--numDirectBits);

}

}

break;

}

*bufOut = buf;

return res;

*/

*status = LZMA_STATUS_NOT_FINISHED; \

return SZ_ERROR_DATA; // for strict mode

// return SZ_OK; // for relaxed mode

}

if (p->remainLen != 0)

{

}

checkEndMarkNow = 1;

}

for (i = 0; i < (unsigned)dummyProcessed; i++)

p->tempBuf[i] = src[i];

// p->remainLen = kMatchSpecLen_Error_Data;

}

bufLimit = src;

(*srcLen) += (unsigned)dummyProcessed - p->tempBufSize;

p->tempBufSize = (unsigned)dummyProcessed;

// p->remainLen = kMatchSpecLen_Error_Data;

}

}

SRes LzmaDec_AllocateProbs(CLzmaDec *p, const Byte *props, unsigned propsSize, ISzAllocPtr alloc)

{

CLzmaProps propNew;

p->prop = propNew;

return SZ_OK;

}

{

CLzmaProps propNew;

SizeT dicBufSize;

{

UInt32 dictSize = propNew.dicSize;

SizeT mask = ((UInt32)1 << 12) - 1;

if (dictSize >= ((UInt32)1 << 30)) mask = ((UInt32)1 << 22) - 1;

dicBufSize = ((SizeT)dictSize + mask) & ~mask;

if (dicBufSize < dictSize)

dicBufSize = dictSize;

*status = LZMA_STATUS_NOT_SPECIFIED;

if (inSize < RC_INIT_SIZE)

return SZ_ERROR_INPUT_EOF;

p.dic = dest;

p.dicBufSize = outSize;

LzmaDec_Init(&p);