/// <summary>
/// Decodes the deflated stream.
/// </summary>
/// <returns>
/// false if more input is needed, or if finished.
/// </returns>
/// <exception cref="SharpZipBaseException">
/// if deflated stream is invalid.
/// </exception>
private bool Decode()
{
switch (mode)
{
case DECODE_HEADER:
return(DecodeHeader());
case DECODE_DICT:
return(DecodeDict());
case DECODE_CHKSUM:
return(DecodeChksum());
case DECODE_BLOCKS:
if (isLastBlock)
{
if (noHeader)
{
mode = FINISHED;
return(false);
}
else
{
input.SkipToByteBoundary();
neededBits = 32;
mode = DECODE_CHKSUM;
return(true);
}
}
int type = input.PeekBits(3);
if (type < 0)
{
return(false);
}
input.DropBits(3);
isLastBlock |= (type & 1) != 0;
switch (type >> 1)
{
case DeflaterConstants.STORED_BLOCK:
input.SkipToByteBoundary();
mode = DECODE_STORED_LEN1;
break;
case DeflaterConstants.STATIC_TREES:
litlenTree = InflaterHuffmanTree.defLitLenTree;
distTree = InflaterHuffmanTree.defDistTree;
mode = DECODE_HUFFMAN;
break;
case DeflaterConstants.DYN_TREES:
dynHeader = new InflaterDynHeader(input);
mode = DECODE_DYN_HEADER;
break;
default:
throw new SharpZipBaseException("Unknown block type " + type);
}
return(true);
case DECODE_STORED_LEN1:
{
if ((uncomprLen = input.PeekBits(16)) < 0)
{
return(false);
}
input.DropBits(16);
mode = DECODE_STORED_LEN2;
}
goto case DECODE_STORED_LEN2; // fall through
case DECODE_STORED_LEN2:
{
int nlen = input.PeekBits(16);
if (nlen < 0)
{
return(false);
}
input.DropBits(16);
if (nlen != (uncomprLen ^ 0xffff))
{
throw new SharpZipBaseException("broken uncompressed block");
}
mode = DECODE_STORED;
}
goto case DECODE_STORED; // fall through
case DECODE_STORED:
{
int more = outputWindow.CopyStored(input, uncomprLen);
uncomprLen -= more;
if (uncomprLen == 0)
{
mode = DECODE_BLOCKS;
return(true);
}
return(!input.IsNeedingInput);
}
case DECODE_DYN_HEADER:
if (!dynHeader.AttemptRead())
{
return(false);
}
litlenTree = dynHeader.LiteralLengthTree;
distTree = dynHeader.DistanceTree;
mode = DECODE_HUFFMAN;
goto case DECODE_HUFFMAN; // fall through
case DECODE_HUFFMAN:
case DECODE_HUFFMAN_LENBITS:
case DECODE_HUFFMAN_DIST:
case DECODE_HUFFMAN_DISTBITS:
return(DecodeHuffman());
case FINISHED:
return(false);
default:
throw new SharpZipBaseException("Inflater.Decode unknown mode");
}
}
private bool Decode()
{
switch (mode)
{
case 0:
return(DecodeHeader());
case 1:
return(DecodeDict());
case 11:
return(DecodeChksum());
case 2:
{
if (isLastBlock)
{
if (noHeader)
{
mode = 12;
return(false);
}
input.SkipToByteBoundary();
neededBits = 32;
mode = 11;
return(true);
}
int num = input.PeekBits(3);
if (num < 0)
{
return(false);
}
input.DropBits(3);
if (((uint)num & (true ? 1u : 0u)) != 0)
{
isLastBlock = true;
}
switch (num >> 1)
{
case 0:
input.SkipToByteBoundary();
mode = 3;
break;
case 1:
litlenTree = InflaterHuffmanTree.defLitLenTree;
distTree = InflaterHuffmanTree.defDistTree;
mode = 7;
break;
case 2:
dynHeader = new InflaterDynHeader();
mode = 6;
break;
default:
throw new SharpZipBaseException(string.Concat((object)"Unknown block type ", (object)num));
}
return(true);
}
case 3:
if ((uncomprLen = input.PeekBits(16)) < 0)
{
return(false);
}
input.DropBits(16);
mode = 4;
goto case 4;
case 4:
{
int num3 = input.PeekBits(16);
if (num3 < 0)
{
return(false);
}
input.DropBits(16);
if (num3 != (uncomprLen ^ 0xFFFF))
{
throw new SharpZipBaseException("broken uncompressed block");
}
mode = 5;
goto case 5;
}
case 5:
{
int num2 = outputWindow.CopyStored(input, uncomprLen);
uncomprLen -= num2;
if (uncomprLen == 0)
{
mode = 2;
return(true);
}
return(!input.IsNeedingInput);
}
case 6:
if (!dynHeader.Decode(input))
{
return(false);
}
litlenTree = dynHeader.BuildLitLenTree();
distTree = dynHeader.BuildDistTree();
mode = 7;
goto case 7;
case 7:
case 8:
case 9:
case 10:
return(DecodeHuffman());
case 12:
return(false);
default:
throw new SharpZipBaseException("Inflater.Decode unknown mode");
}
}
private bool Decode()
{
int num2;
int num3;
switch (mode)
{
case 0:
return(DecodeHeader());
case 1:
return(DecodeDict());
case 2:
if (!isLastBlock)
{
int num = input.PeekBits(3);
if (num < 0)
{
return(false);
}
input.DropBits(3);
if ((num & 1) != 0)
{
isLastBlock = true;
}
switch ((num >> 1))
{
case 0:
input.SkipToByteBoundary();
mode = 3;
goto Label_0134;
case 1:
litlenTree = InflaterHuffmanTree.DefLitLenTree;
distTree = InflaterHuffmanTree.DefDistTree;
mode = 7;
goto Label_0134;
case 2:
dynHeader = new InflaterDynHeader();
mode = 6;
goto Label_0134;
}
throw new SharpZipBaseException("Unknown block type " + num);
}
if (!noHeader)
{
input.SkipToByteBoundary();
neededBits = 0x20;
mode = DECODE_CHKSUM;
return(true);
}
mode = FINISHED;
return(false);
case 3:
uncomprLen = input.PeekBits(0x10);
if (uncomprLen >= 0)
{
input.DropBits(0x10);
mode = 4;
goto Label_0167;
}
return(false);
case 4:
goto Label_0167;
case 5:
goto Label_01A9;
case 6:
if (dynHeader.Decode(input))
{
litlenTree = dynHeader.BuildLitLenTree();
distTree = dynHeader.BuildDistTree();
mode = 7;
goto Label_022D;
}
return(false);
case 7:
case 8:
case 9:
case 10:
goto Label_022D;
case DECODE_CHKSUM:
return(DecodeChksum());
case FINISHED:
return(false);
default:
throw new SharpZipBaseException("Inflater.Decode unknown mode");
}
Label_0134:
return(true);
Label_0167:
num2 = input.PeekBits(0x10);
if (num2 < 0)
{
return(false);
}
input.DropBits(0x10);
if (num2 != (uncomprLen ^ 0xffff))
{
throw new SharpZipBaseException("broken uncompressed block");
}
mode = 5;
Label_01A9:
num3 = outputWindow.CopyStored(input, uncomprLen);
uncomprLen -= num3;
if (uncomprLen == 0)
{
mode = 2;
return(true);
}
return(!input.IsNeedingInput);
Label_022D:
return(DecodeHuffman());
}
/// <summary>
/// Decodes the deflated stream.
/// </summary>
/// <returns>
/// false if more input is needed, or if finished.
/// </returns>
/// <exception cref="SharpZipBaseException">
/// if deflated stream is invalid.
/// </exception>
private bool Decode()
{
switch (mode)
{
case DECODE_HEADER:
return(DecodeHeader());
case DECODE_DICT:
return(DecodeDict());
case DECODE_CHKSUM:
return(DecodeChksum());
case DECODE_BLOCKS:
if (isLastBlock)
{
if (noHeader)
{
mode = FINISHED;
return(false);
}
else
{
input.SkipToByteBoundary();
neededBits = 32;
mode = DECODE_CHKSUM;
return(true);
}
}
int blockType;
if (!ReadHeader(ref isLastBlock, out blockType))
{
return(false);
}
switch (blockType)
{
case STORED_BLOCK:
input.SkipToByteBoundary();
mode = DECODE_STORED_LEN1;
break;
case STATIC_TREES:
litlenTree = InflaterHuffmanTree.defLitLenTree;
distTree = InflaterHuffmanTree.defDistTree;
mode = DECODE_HUFFMAN;
break;
case DYN_TREES:
dynHeader = new InflaterDynHeader();
mode = DECODE_DYN_HEADER;
break;
default:
throw new SharpZipBaseException("Unknown block type " + blockType);
}
return(true);
case DECODE_STORED_LEN1:
if (!DecodeStoredLength())
{
return(false);
}
mode = DECODE_STORED;
goto case DECODE_STORED; // fall through
case DECODE_STORED:
{
int more = outputWindow.CopyStored(input, uncomprLen);
uncomprLen -= more;
if (uncomprLen == 0)
{
mode = DECODE_BLOCKS;
return(true);
}
return(!input.IsNeedingInput);
}
case DECODE_DYN_HEADER:
if (!dynHeader.Decode(input))
{
return(false);
}
litlenTree = dynHeader.BuildLitLenTree();
distTree = dynHeader.BuildDistTree();
mode = DECODE_HUFFMAN;
goto case DECODE_HUFFMAN; // fall through
case DECODE_HUFFMAN:
case DECODE_HUFFMAN_LENBITS:
case DECODE_HUFFMAN_DIST:
case DECODE_HUFFMAN_DISTBITS:
return(DecodeHuffman());
case FINISHED:
return(false);
default:
throw new SharpZipBaseException("Inflater.Decode unknown mode");
}
}
private bool Decode()
{
switch (mode)
{
case 0:
return(DecodeHeader());
case 1:
return(DecodeDict());
case 11:
return(DecodeChecksum());
case 2:
if (isLastBlock)
{
mode = 12;
return(false);
}
int type = input.PeekBits(3);
if (type < 0)
{
return(false);
}
input.DropBits(3);
isLastBlock |= (type & 1) != 0;
switch (type >> 1)
{
case 0:
input.SkipToByteBoundary();
mode = 3;
break;
case 1:
litlenTree = null;
distTree = null;
mode = 7;
break;
case 2:
dynHeader = new Header();
mode = 6;
break;
}
return(true);
case 3:
{
if ((uncomprLen = input.PeekBits(16)) < 0)
{
return(false);
}
input.DropBits(16);
mode = 4;
}
goto case 4;
case 4:
{
int nlen = input.PeekBits(16);
if (nlen < 0)
{
return(false);
}
input.DropBits(16);
mode = 5;
}
goto case 5;
case 5:
{
int more = output.CopyStored(input, uncomprLen);
uncomprLen -= more;
if (uncomprLen == 0)
{
mode = 2;
return(true);
}
return(!input.isNeedingInput);
}
case 6:
if (!dynHeader.Decode(input))
{
return(false);
}
litlenTree = dynHeader.BuildLitLenTree();
distTree = dynHeader.BuildDistTree();
mode = 7;
goto case 7;
case 7:
case 8:
case 9:
case 10:
return(DecodeHuffman());
case 12:
return(false);
default:
throw new Exception("Inflater.Decode unknown mode");
}
}
/// <summary>
/// Decodes the deflated stream.
/// </summary>
/// <returns>
/// false if more input is needed, or if State.Done.
/// </returns>
/// <exception cref="InvalidDataException">
/// if deflated stream is invalid.
/// </exception>
bool Decode()
{
switch (mode)
{
case State.Header:
return(DecodeHeader());
case State.Dictionary:
return(DecodeDict());
case State.Checksum:
return(DecodeChksum());
case State.Blocks:
if (isLastBlock)
{
if (noHeader)
{
mode = State.Done;
return(false);
}
else
{
input.SkipToByteBoundary();
neededBits = 32;
mode = State.Checksum;
return(true);
}
}
var type = input.PeekBits(3);
if (type < 0)
{
return(false);
}
input.DropBits(3);
isLastBlock |= (type & 1) != 0;
switch (type >> 1)
{
case DeflaterConstants.StoredBlock:
input.SkipToByteBoundary();
mode = State.StoredLen1;
break;
case DeflaterConstants.StaticTree:
litlenTree = InflaterHuffmanTree.DefLitLenTree;
distTree = InflaterHuffmanTree.DefDistTree;
mode = State.Huffman;
break;
case DeflaterConstants.DynamicTree:
dynHeader = new InflaterDynHeader();
mode = State.DynamicHeader;
break;
default:
throw new NotSupportedException("Unknown block type " + type);
}
return(true);
case State.StoredLen1:
{
if ((uncomprLen = input.PeekBits(16)) < 0)
{
return(false);
}
input.DropBits(16);
mode = State.StoredLen2;
}
goto case State.StoredLen2; // fall through
case State.StoredLen2:
{
var nlen = input.PeekBits(16);
if (nlen < 0)
{
return(false);
}
input.DropBits(16);
if (nlen != (uncomprLen ^ 0xffff))
{
throw new InvalidDataException("broken uncompressed block");
}
mode = State.Stored;
goto case State.Stored; // fall through
}
case State.Stored:
{
var more = outputWindow.CopyStored(input, uncomprLen);
uncomprLen -= more;
if (uncomprLen == 0)
{
mode = State.Blocks;
return(true);
}
return(!input.IsNeedingInput);
}
case State.DynamicHeader:
if (!dynHeader.Decode(input))
{
return(false);
}
litlenTree = dynHeader.BuildLitLenTree();
distTree = dynHeader.BuildDistTree();
mode = State.Huffman;
goto case State.Huffman; // fall through
case State.Huffman:
case State.HuffmanLenBits:
case State.HuffmanDist:
case State.HuffmanDistBits:
return(DecodeHuffman());
case State.Done:
return(false);
default:
throw new InvalidDataException("Inflater.Decode unknown mode");
}
}
