diff --git a/crypto/bzip2/src/CBZip2InputStream.cs b/crypto/bzip2/src/CBZip2InputStream.cs
index 82ff83e42..82f397d38 100644
--- a/crypto/bzip2/src/CBZip2InputStream.cs
+++ b/crypto/bzip2/src/CBZip2InputStream.cs
@@ -57,13 +57,15 @@ namespace Org.BouncyCastle.Apache.Bzip2
Cadvise();
}
- private void MakeMaps() {
- int i;
+ private void MakeMaps()
+ {
nInUse = 0;
- for (i = 0; i < 256; i++) {
- if (inUse[i]) {
- seqToUnseq[nInUse] = (char) i;
- unseqToSeq[i] = (char) nInUse;
+ for (int i = 0; i < 256; i++)
+ {
+ if (inUse[i])
+ {
+ seqToUnseq[nInUse] = (char)i;
+ unseqToSeq[i] = (char)nInUse;
nInUse++;
}
}
@@ -150,51 +152,56 @@ namespace Org.BouncyCastle.Apache.Bzip2
SetupBlock();
}
- internal static int[][] InitIntArray(int n1, int n2) {
+ internal static int[][] InitIntArray(int n1, int n2)
+ {
int[][] a = new int[n1][];
- for (int k = 0; k < n1; ++k) {
+ for (int k = 0; k < n1; ++k)
+ {
a[k] = new int[n2];
}
return a;
}
- internal static char[][] InitCharArray(int n1, int n2) {
- char[][] a = new char[n1][];
- for (int k = 0; k < n1; ++k) {
- a[k] = new char[n2];
+ internal static byte[][] InitByteArray(int n1, int n2)
+ {
+ byte[][] a = new byte[n1][];
+ for (int k = 0; k < n1; ++k)
+ {
+ a[k] = new byte[n2];
}
return a;
}
- public override int ReadByte() {
- if (streamEnd) {
+ public override int ReadByte()
+ {
+ if (streamEnd)
return -1;
- } else {
- int retChar = currentChar;
- switch (currentState) {
- case START_BLOCK_STATE:
- break;
- case RAND_PART_A_STATE:
- break;
- case RAND_PART_B_STATE:
- SetupRandPartB();
- break;
- case RAND_PART_C_STATE:
- SetupRandPartC();
- break;
- case NO_RAND_PART_A_STATE:
- break;
- case NO_RAND_PART_B_STATE:
- SetupNoRandPartB();
- break;
- case NO_RAND_PART_C_STATE:
- SetupNoRandPartC();
- break;
- default:
- break;
- }
- return retChar;
- }
+
+ int retChar = currentChar;
+ switch (currentState)
+ {
+ case START_BLOCK_STATE:
+ break;
+ case RAND_PART_A_STATE:
+ break;
+ case RAND_PART_B_STATE:
+ SetupRandPartB();
+ break;
+ case RAND_PART_C_STATE:
+ SetupRandPartC();
+ break;
+ case NO_RAND_PART_A_STATE:
+ break;
+ case NO_RAND_PART_B_STATE:
+ SetupNoRandPartB();
+ break;
+ case NO_RAND_PART_C_STATE:
+ SetupNoRandPartC();
+ break;
+ default:
+ break;
+ }
+ return retChar;
}
private void Initialize() {
@@ -241,29 +248,24 @@ namespace Org.BouncyCastle.Apache.Bzip2
storedBlockCRC = BsGetInt32();
- if (BsR(1) == 1) {
- blockRandomised = true;
- } else {
- blockRandomised = false;
- }
+ blockRandomised = BsR(1) == 1;
- // currBlockNo++;
GetAndMoveToFrontDecode();
mCrc.InitialiseCRC();
currentState = START_BLOCK_STATE;
}
- private void EndBlock() {
+ private void EndBlock()
+ {
computedBlockCRC = mCrc.GetFinalCRC();
/* A bad CRC is considered a fatal error. */
- if (storedBlockCRC != computedBlockCRC) {
+ if (storedBlockCRC != computedBlockCRC)
+ {
CrcError();
}
- computedCombinedCRC = (computedCombinedCRC << 1)
- | (int)(((uint)computedCombinedCRC) >> 31);
- computedCombinedCRC ^= computedBlockCRC;
+ computedCombinedCRC = Integers.RotateLeft(computedCombinedCRC, 1) ^ computedBlockCRC;
}
private void Complete() {
@@ -311,7 +313,7 @@ namespace Org.BouncyCastle.Apache.Bzip2
int zzi;
char thech = '\0';
try {
- thech = (char) bsStream.ReadByte();
+ thech = (char)bsStream.ReadByte();
} catch (IOException) {
CompressedStreamEOF();
}
@@ -328,33 +330,39 @@ namespace Org.BouncyCastle.Apache.Bzip2
return v;
}
- private char BsGetUChar() {
- return (char) BsR(8);
+ private char BsGetUChar()
+ {
+ return (char)BsR(8);
}
- private int BsGetint() {
- int u = 0;
- u = (u << 8) | BsR(8);
- u = (u << 8) | BsR(8);
- u = (u << 8) | BsR(8);
- u = (u << 8) | BsR(8);
- return u;
+ private int BsGetint()
+ {
+ //int u = 0;
+ //u = (u << 8) | BsR(8);
+ //u = (u << 8) | BsR(8);
+ //u = (u << 8) | BsR(8);
+ //u = (u << 8) | BsR(8);
+ //return u;
+ int u = BsR(16) << 16;
+ return u | BsR(16);
}
- private int BsGetIntVS(int numBits) {
- return (int) BsR(numBits);
+ private int BsGetIntVS(int numBits)
+ {
+ return BsR(numBits);
}
- private int BsGetInt32() {
- return (int) BsGetint();
+ private int BsGetInt32()
+ {
+ return BsGetint();
}
- private void HbCreateDecodeTables(int[] limit, int[] basev,
- int[] perm, char[] length,
- int minLen, int maxLen, int alphaSize) {
- int pp, i, j, vec;
+ private void HbCreateDecodeTables(int[] limit, int[] basev, int[] perm, byte[] length, int minLen, int maxLen,
+ int alphaSize)
+ {
+ int i, j, vec;
- pp = 0;
+ int pp = 0;
for (i = minLen; i <= maxLen; i++) {
for (j = 0; j < alphaSize; j++) {
if (length[j] == i) {
@@ -390,31 +398,34 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
}
- private void RecvDecodingTables() {
- char[][] len = InitCharArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
+ private void RecvDecodingTables()
+ {
+ byte[][] len = InitByteArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
int i, j, t, nGroups, nSelectors, alphaSize;
int minLen, maxLen;
bool[] inUse16 = new bool[16];
/* Receive the mapping table */
- for (i = 0; i < 16; i++) {
- if (BsR(1) == 1) {
- inUse16[i] = true;
- } else {
- inUse16[i] = false;
- }
- }
-
- for (i = 0; i < 256; i++) {
- inUse[i] = false;
+ for (i = 0; i < 16; i++)
+ {
+ inUse16[i] = BsR(1) == 1;
}
- for (i = 0; i < 16; i++) {
- if (inUse16[i]) {
- for (j = 0; j < 16; j++) {
- if (BsR(1) == 1) {
- inUse[i * 16 + j] = true;
- }
+ for (i = 0; i < 16; i++)
+ {
+ int i16 = i * 16;
+ if (inUse16[i])
+ {
+ for (j = 0; j < 16; j++)
+ {
+ inUse[i16 + j] = BsR(1) == 1;
+ }
+ }
+ else
+ {
+ for (j = 0; j < 16; j++)
+ {
+ inUse[i16 + j] = false;
}
}
}
@@ -430,7 +441,7 @@ namespace Org.BouncyCastle.Apache.Bzip2
while (BsR(1) == 1) {
j++;
}
- selectorMtf[i] = (char) j;
+ selectorMtf[i] = (char)j;
}
/* Undo the MTF values for the selectors. */
@@ -454,39 +465,52 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
/* Now the coding tables */
- for (t = 0; t < nGroups; t++) {
+ for (t = 0; t < nGroups; t++)
+ {
+ byte[] len_t = len[t];
int curr = BsR(5);
- for (i = 0; i < alphaSize; i++) {
- while (BsR(1) == 1) {
- if (BsR(1) == 0) {
+ for (i = 0; i < alphaSize; i++)
+ {
+ while (BsR(1) == 1)
+ {
+ if (BsR(1) == 0)
+ {
curr++;
- } else {
+ }
+ else
+ {
curr--;
}
}
- len[t][i] = (char) curr;
+ len_t[i] = (byte)curr;
}
}
/* Create the Huffman decoding tables */
- for (t = 0; t < nGroups; t++) {
+ for (t = 0; t < nGroups; t++)
+ {
minLen = 32;
maxLen = 0;
- for (i = 0; i < alphaSize; i++) {
- if (len[t][i] > maxLen) {
- maxLen = len[t][i];
+ byte[] len_t = len[t];
+ for (i = 0; i < alphaSize; i++)
+ {
+ int lti = len_t[i];
+ if (lti > maxLen)
+ {
+ maxLen = lti;
}
- if (len[t][i] < minLen) {
- minLen = len[t][i];
+ if (lti < minLen)
+ {
+ minLen = lti;
}
}
- HbCreateDecodeTables(limit[t], basev[t], perm[t], len[t], minLen,
- maxLen, alphaSize);
+ HbCreateDecodeTables(limit[t], basev[t], perm[t], len_t, minLen, maxLen, alphaSize);
minLens[t] = minLen;
}
}
- private void GetAndMoveToFrontDecode() {
+ private void GetAndMoveToFrontDecode()
+ {
char[] yy = new char[256];
int i, j, nextSym, limitLast;
int EOB, groupNo, groupPos;
@@ -505,19 +529,22 @@ namespace Org.BouncyCastle.Apache.Bzip2
in a separate pass, and so saves a block's worth of
cache misses.
*/
- for (i = 0; i <= 255; i++) {
+ for (i = 0; i <= 255; i++)
+ {
unzftab[i] = 0;
}
- for (i = 0; i <= 255; i++) {
- yy[i] = (char) i;
+ for (i = 0; i <= 255; i++)
+ {
+ yy[i] = (char)i;
}
last = -1;
{
int zt, zn, zvec, zj;
- if (groupPos == 0) {
+ if (groupPos == 0)
+ {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
@@ -525,19 +552,25 @@ namespace Org.BouncyCastle.Apache.Bzip2
zt = selector[groupNo];
zn = minLens[zt];
zvec = BsR(zn);
- while (zvec > limit[zt][zn]) {
+ while (zvec > limit[zt][zn])
+ {
zn++;
{
{
- while (bsLive < 1) {
+ while (bsLive < 1)
+ {
int zzi;
char thech = '\0';
- try {
- thech = (char) bsStream.ReadByte();
- } catch (IOException) {
+ try
+ {
+ thech = (char)bsStream.ReadByte();
+ }
+ catch (IOException)
+ {
CompressedStreamEOF();
}
- if (thech == '\uffff') {
+ if (thech == '\uffff')
+ {
CompressedStreamEOF();
}
zzi = thech;
@@ -553,26 +586,28 @@ namespace Org.BouncyCastle.Apache.Bzip2
nextSym = perm[zt][zvec - basev[zt][zn]];
}
- while (true) {
-
- if (nextSym == EOB) {
- break;
- }
-
- if (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB) {
+ while (nextSym != EOB)
+ {
+ if (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB)
+ {
char ch;
int s = -1;
int N = 1;
- do {
- if (nextSym == BZip2Constants.RUNA) {
- s = s + (0 + 1) * N;
- } else if (nextSym == BZip2Constants.RUNB) {
- s = s + (1 + 1) * N;
- }
+ do
+ {
+ if (nextSym == BZip2Constants.RUNA)
+ {
+ s += (0 + 1) * N;
+ }
+ else if (nextSym == BZip2Constants.RUNB)
+ {
+ s += (1 + 1) * N;
+ }
N = N * 2;
{
int zt, zn, zvec, zj;
- if (groupPos == 0) {
+ if (groupPos == 0)
+ {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
@@ -580,19 +615,25 @@ namespace Org.BouncyCastle.Apache.Bzip2
zt = selector[groupNo];
zn = minLens[zt];
zvec = BsR(zn);
- while (zvec > limit[zt][zn]) {
+ while (zvec > limit[zt][zn])
+ {
zn++;
{
{
- while (bsLive < 1) {
+ while (bsLive < 1)
+ {
int zzi;
char thech = '\0';
- try {
- thech = (char) bsStream.ReadByte();
- } catch (IOException) {
+ try
+ {
+ thech = (char)bsStream.ReadByte();
+ }
+ catch (IOException)
+ {
CompressedStreamEOF();
}
- if (thech == '\uffff') {
+ if (thech == '\uffff')
+ {
CompressedStreamEOF();
}
zzi = thech;
@@ -607,55 +648,60 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
nextSym = perm[zt][zvec - basev[zt][zn]];
}
- } while (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB);
+ }
+ while (nextSym == BZip2Constants.RUNA || nextSym == BZip2Constants.RUNB);
s++;
ch = seqToUnseq[yy[0]];
unzftab[ch] += s;
- while (s > 0) {
+ while (s > 0)
+ {
last++;
ll8[last] = ch;
s--;
}
- if (last >= limitLast) {
+ if (last >= limitLast)
+ {
BlockOverrun();
}
continue;
- } else {
- char tmp;
- last++;
- if (last >= limitLast) {
+ }
+ else
+ {
+ if (++last >= limitLast)
+ {
BlockOverrun();
}
- tmp = yy[nextSym - 1];
+ char tmp = yy[nextSym - 1];
unzftab[seqToUnseq[tmp]]++;
ll8[last] = seqToUnseq[tmp];
/*
- This loop is hammered during decompression,
- hence the unrolling.
-
- for (j = nextSym-1; j > 0; j--) yy[j] = yy[j-1];
- */
-
- j = nextSym - 1;
- for (; j > 3; j -= 4) {
- yy[j] = yy[j - 1];
- yy[j - 1] = yy[j - 2];
- yy[j - 2] = yy[j - 3];
- yy[j - 3] = yy[j - 4];
+ * This loop is hammered during decompression, hence avoid
+ * native method call overhead of Array.Copy for very
+ * small ranges to copy.
+ */
+ if (nextSym <= 16)
+ {
+ for (j = nextSym - 1; j > 0; --j)
+ {
+ yy[j] = yy[j - 1];
+ }
}
- for (; j > 0; j--) {
- yy[j] = yy[j - 1];
+ else
+ {
+ Array.Copy(yy, 0, yy, 1, nextSym - 1);
}
yy[0] = tmp;
+
{
int zt, zn, zvec, zj;
- if (groupPos == 0) {
+ if (groupPos == 0)
+ {
groupNo++;
groupPos = BZip2Constants.G_SIZE;
}
@@ -663,16 +709,21 @@ namespace Org.BouncyCastle.Apache.Bzip2
zt = selector[groupNo];
zn = minLens[zt];
zvec = BsR(zn);
- while (zvec > limit[zt][zn]) {
+ while (zvec > limit[zt][zn])
+ {
zn++;
{
{
- while (bsLive < 1) {
+ while (bsLive < 1)
+ {
int zzi;
char thech = '\0';
- try {
- thech = (char) bsStream.ReadByte();
- } catch (IOException) {
+ try
+ {
+ thech = (char)bsStream.ReadByte();
+ }
+ catch (IOException)
+ {
CompressedStreamEOF();
}
zzi = thech;
@@ -705,7 +756,7 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
for (i = 0; i <= last; i++) {
- ch = (char) ll8[i];
+ ch = ll8[i];
tt[cftab[ch]] = i;
cftab[ch]++;
}
diff --git a/crypto/bzip2/src/CBZip2OutputStream.cs b/crypto/bzip2/src/CBZip2OutputStream.cs
index 2a70b6856..e81f6ffc1 100644
--- a/crypto/bzip2/src/CBZip2OutputStream.cs
+++ b/crypto/bzip2/src/CBZip2OutputStream.cs
@@ -71,95 +71,96 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
}
- protected static void HbMakeCodeLengths(char[] len, int[] freq,
- int alphaSize, int maxLen)
+ protected static void HbMakeCodeLengths(byte[] len, int[] freq, int alphaSize, int maxLen)
{
/*
Nodes and heap entries run from 1. Entry 0
for both the heap and nodes is a sentinel.
*/
- int nNodes, nHeap, n1, n2, i, j, k;
- bool tooLong;
-
int[] heap = new int[BZip2Constants.MAX_ALPHA_SIZE + 2];
int[] weight = new int[BZip2Constants.MAX_ALPHA_SIZE * 2];
int[] parent = new int[BZip2Constants.MAX_ALPHA_SIZE * 2];
- for (i = 0; i < alphaSize; i++) {
+ for (int i = 0; i < alphaSize; i++)
+ {
weight[i + 1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
}
- while (true) {
- nNodes = alphaSize;
- nHeap = 0;
+ while (true)
+ {
+ int nNodes = alphaSize;
+ int nHeap = 0;
heap[0] = 0;
weight[0] = 0;
parent[0] = -2;
- for (i = 1; i <= alphaSize; i++) {
+ for (int i = 1; i <= alphaSize; i++)
+ {
parent[i] = -1;
- nHeap++;
- heap[nHeap] = i;
+ heap[++nHeap] = i;
{
- int zz, tmp;
- zz = nHeap;
- tmp = heap[zz];
- while (weight[tmp] < weight[heap[zz >> 1]]) {
+ int zz = nHeap;
+ int tmp = heap[zz];
+ while (weight[tmp] < weight[heap[zz >> 1]])
+ {
heap[zz] = heap[zz >> 1];
zz >>= 1;
}
heap[zz] = tmp;
}
}
- if (!(nHeap < (BZip2Constants.MAX_ALPHA_SIZE + 2))) {
+ if (!(nHeap < (BZip2Constants.MAX_ALPHA_SIZE + 2)))
+ {
Panic();
}
- while (nHeap > 1) {
- n1 = heap[1];
- heap[1] = heap[nHeap];
- nHeap--;
+ while (nHeap > 1)
+ {
+ int n1 = heap[1];
+ heap[1] = heap[nHeap--];
{
- int zz = 0, yy = 0, tmp = 0;
- zz = 1;
- tmp = heap[zz];
+ int zz = 1;
+ int tmp = heap[zz];
while (true) {
- yy = zz << 1;
- if (yy > nHeap) {
+ int yy = zz << 1;
+ if (yy > nHeap)
break;
- }
+
if (yy < nHeap
- && weight[heap[yy + 1]] < weight[heap[yy]]) {
+ && weight[heap[yy + 1]] < weight[heap[yy]])
+ {
yy++;
}
- if (weight[tmp] < weight[heap[yy]]) {
+
+ if (weight[tmp] < weight[heap[yy]])
break;
- }
+
heap[zz] = heap[yy];
zz = yy;
}
heap[zz] = tmp;
}
- n2 = heap[1];
- heap[1] = heap[nHeap];
- nHeap--;
+ int n2 = heap[1];
+ heap[1] = heap[nHeap--];
{
- int zz = 0, yy = 0, tmp = 0;
- zz = 1;
- tmp = heap[zz];
- while (true) {
- yy = zz << 1;
- if (yy > nHeap) {
+ int zz = 1;
+ int tmp = heap[zz];
+ while (true)
+ {
+ int yy = zz << 1;
+ if (yy > nHeap)
break;
- }
+
if (yy < nHeap
- && weight[heap[yy + 1]] < weight[heap[yy]]) {
+ && weight[heap[yy + 1]] < weight[heap[yy]])
+ {
yy++;
}
- if (weight[tmp] < weight[heap[yy]]) {
+
+ if (weight[tmp] < weight[heap[yy]])
break;
- }
+
heap[zz] = heap[yy];
zz = yy;
}
@@ -176,43 +177,46 @@ namespace Org.BouncyCastle.Apache.Bzip2
(weight[n2] & 0x000000ff))));
parent[nNodes] = -1;
- nHeap++;
- heap[nHeap] = nNodes;
+ heap[++nHeap] = nNodes;
{
- int zz = 0, tmp = 0;
- zz = nHeap;
- tmp = heap[zz];
- while (weight[tmp] < weight[heap[zz >> 1]]) {
+ int zz = nHeap;
+ int tmp = heap[zz];
+ while (weight[tmp] < weight[heap[zz >> 1]])
+ {
heap[zz] = heap[zz >> 1];
zz >>= 1;
}
heap[zz] = tmp;
}
}
- if (!(nNodes < (BZip2Constants.MAX_ALPHA_SIZE * 2))) {
+ if (!(nNodes < (BZip2Constants.MAX_ALPHA_SIZE * 2)))
+ {
Panic();
}
- tooLong = false;
- for (i = 1; i <= alphaSize; i++) {
- j = 0;
- k = i;
- while (parent[k] >= 0) {
+ bool tooLong = false;
+ for (int i = 1; i <= alphaSize; i++)
+ {
+ int j = 0;
+ int k = i;
+ while (parent[k] >= 0)
+ {
k = parent[k];
j++;
}
- len[i - 1] = (char) j;
- if (j > maxLen) {
+ len[i - 1] = (byte)j;
+ if (j > maxLen)
+ {
tooLong = true;
}
}
- if (!tooLong) {
+ if (!tooLong)
break;
- }
- for (i = 1; i < alphaSize; i++) {
- j = weight[i] >> 8;
+ for (int i = 1; i < alphaSize; i++)
+ {
+ int j = weight[i] >> 8;
j = 1 + (j / 2);
weight[i] = j << 8;
}
@@ -233,14 +237,15 @@ namespace Org.BouncyCastle.Apache.Bzip2
always: in the range 0 .. 9.
The current block size is 100000 * this number.
*/
- int blockSize100k;
+ readonly int blockSize100k;
+
+ private int allowableBlockSize;
bool blockRandomised;
- int bytesOut;
int bsBuff;
int bsLive;
- CRC mCrc = new CRC();
+ readonly CRC mCrc = new CRC();
private bool[] inUse = new bool[256];
private int nInUse;
@@ -274,31 +279,31 @@ namespace Org.BouncyCastle.Apache.Bzip2
private int currentByte = -1;
private int runLength = 0;
- public CBZip2OutputStream(Stream inStream)
- : this(inStream, 9)
+ public CBZip2OutputStream(Stream outStream)
+ : this(outStream, 9)
{
}
- public CBZip2OutputStream(Stream inStream, int inBlockSize)
+ public CBZip2OutputStream(Stream outStream, int blockSize)
{
blockBytes = null;
quadrantShorts = null;
zptr = null;
ftab = null;
- inStream.WriteByte((byte)'B');
- inStream.WriteByte((byte)'Z');
+ outStream.WriteByte((byte)'B');
+ outStream.WriteByte((byte)'Z');
- BsSetStream(inStream);
+ BsSetStream(outStream);
workFactor = 50;
- if (inBlockSize > 9) {
- inBlockSize = 9;
+ if (blockSize > 9) {
+ blockSize = 9;
}
- if (inBlockSize < 1) {
- inBlockSize = 1;
+ if (blockSize < 1) {
+ blockSize = 1;
}
- blockSize100k = inBlockSize;
+ blockSize100k = blockSize;
AllocateCompressStructures();
Initialize();
InitBlock();
@@ -395,7 +400,8 @@ namespace Org.BouncyCastle.Apache.Bzip2
base.Dispose(disposing);
}
#else
- public override void Close() {
+ public override void Close()
+ {
if (closed)
return;
@@ -408,12 +414,13 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
#endif
- public void Finish() {
- if (finished) {
+ public void Finish()
+ {
+ if (finished)
return;
- }
- if (runLength > 0) {
+ if (runLength > 0)
+ {
WriteRun();
}
currentByte = -1;
@@ -426,15 +433,15 @@ namespace Org.BouncyCastle.Apache.Bzip2
Flush();
}
- public override void Flush() {
+ public override void Flush()
+ {
bsStream.Flush();
}
private int blockCRC, combinedCRC;
- private void Initialize() {
- bytesOut = 0;
-
+ private void Initialize()
+ {
/* Write `magic' bytes h indicating file-format == huffmanised,
followed by a digit indicating blockSize100k.
*/
@@ -444,8 +451,6 @@ namespace Org.BouncyCastle.Apache.Bzip2
combinedCRC = 0;
}
- private int allowableBlockSize;
-
private void InitBlock()
{
mCrc.InitialiseCRC();
@@ -460,10 +465,10 @@ namespace Org.BouncyCastle.Apache.Bzip2
allowableBlockSize = BZip2Constants.baseBlockSize * blockSize100k - 20;
}
- private void EndBlock() {
+ private void EndBlock()
+ {
blockCRC = mCrc.GetFinalCRC();
- combinedCRC = (combinedCRC << 1) | (int)(((uint)combinedCRC) >> 31);
- combinedCRC ^= blockCRC;
+ combinedCRC = Integers.RotateLeft(combinedCRC, 1) ^ blockCRC;
/* sort the block and establish posn of original string */
DoReversibleTransformation();
@@ -518,131 +523,150 @@ namespace Org.BouncyCastle.Apache.Bzip2
BsFinishedWithStream();
}
- private void HbAssignCodes(int[] code, char[] length, int minLen,
- int maxLen, int alphaSize) {
- int n, vec, i;
-
- vec = 0;
- for (n = minLen; n <= maxLen; n++) {
- for (i = 0; i < alphaSize; i++) {
- if (length[i] == n) {
+ private void HbAssignCodes(int[] code, byte[] length, int minLen, int maxLen, int alphaSize)
+ {
+ int vec = 0;
+ for (int n = minLen; n <= maxLen; n++)
+ {
+ for (int i = 0; i < alphaSize; i++)
+ {
+ if (length[i] == n)
+ {
code[i] = vec;
vec++;
}
- };
+ }
vec <<= 1;
}
}
- private void BsSetStream(Stream f) {
+ private void BsSetStream(Stream f)
+ {
bsStream = f;
bsLive = 0;
bsBuff = 0;
- bytesOut = 0;
}
- private void BsFinishedWithStream() {
- while (bsLive > 0) {
- int ch = (bsBuff >> 24);
- try {
- bsStream.WriteByte((byte)ch); // write 8-bit
- } catch (IOException e) {
- throw e;
- }
+ private void BsFinishedWithStream()
+ {
+ while (bsLive > 0)
+ {
+ bsStream.WriteByte((byte)(bsBuff >> 24)); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
- bytesOut++;
}
}
- private void BsW(int n, int v) {
- while (bsLive >= 8) {
- int ch = (bsBuff >> 24);
- try {
- bsStream.WriteByte((byte)ch); // write 8-bit
- } catch (IOException e) {
- throw e;
- }
+ private void BsW(int n, int v)
+ {
+ while (bsLive >= 8)
+ {
+ bsStream.WriteByte((byte)(bsBuff >> 24)); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
- bytesOut++;
}
- bsBuff |= (v << (32 - bsLive - n));
+ bsBuff |= v << (32 - bsLive - n);
bsLive += n;
}
- private void BsPutUChar(int c) {
+ private void BsPutUChar(int c)
+ {
BsW(8, c);
}
- private void BsPutint(int u) {
- BsW(8, (u >> 24) & 0xff);
- BsW(8, (u >> 16) & 0xff);
- BsW(8, (u >> 8) & 0xff);
- BsW(8, u & 0xff);
+ private void BsPutint(int u)
+ {
+ //BsW(8, (u >> 24) & 0xff);
+ //BsW(8, (u >> 16) & 0xff);
+ //BsW(8, (u >> 8) & 0xff);
+ //BsW(8, u & 0xff);
+ BsW(16, (u >> 16) & 0xFFFF);
+ BsW(16, u & 0xFFFF);
}
- private void BsPutIntVS(int numBits, int c) {
+ private void BsPutIntVS(int numBits, int c)
+ {
BsW(numBits, c);
}
- private void SendMTFValues() {
- char[][] len = CBZip2InputStream.InitCharArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
+ private void SendMTFValues()
+ {
+ byte[][] len = CBZip2InputStream.InitByteArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
int v, t, i, j, gs, ge, bt, bc, iter;
int nSelectors = 0, alphaSize, minLen, maxLen, selCtr;
int nGroups;
alphaSize = nInUse + 2;
- for (t = 0; t < BZip2Constants.N_GROUPS; t++) {
- for (v = 0; v < alphaSize; v++) {
- len[t][v] = (char) GREATER_ICOST;
+ for (t = 0; t < BZip2Constants.N_GROUPS; t++)
+ {
+ byte[] len_t = len[t];
+ for (v = 0; v < alphaSize; v++)
+ {
+ len_t[v] = GREATER_ICOST;
}
}
/* Decide how many coding tables to use */
- if (nMTF <= 0) {
+ if (nMTF <= 0)
+ {
Panic();
}
- if (nMTF < 200) {
+ if (nMTF < 200)
+ {
nGroups = 2;
- } else if (nMTF < 600) {
+ }
+ else if (nMTF < 600)
+ {
nGroups = 3;
- } else if (nMTF < 1200) {
+ }
+ else if (nMTF < 1200)
+ {
nGroups = 4;
- } else if (nMTF < 2400) {
+ }
+ else if (nMTF < 2400)
+ {
nGroups = 5;
- } else {
+ }
+ else
+ {
nGroups = 6;
}
- /* Generate an initial set of coding tables */ {
- int nPart, remF, tFreq, aFreq;
+ /* Generate an initial set of coding tables */
+ {
+ int tFreq, aFreq;
- nPart = nGroups;
- remF = nMTF;
+ int nPart = nGroups;
+ int remF = nMTF;
gs = 0;
- while (nPart > 0) {
+ while (nPart > 0)
+ {
tFreq = remF / nPart;
ge = gs - 1;
aFreq = 0;
- while (aFreq < tFreq && ge < alphaSize - 1) {
- ge++;
- aFreq += mtfFreq[ge];
+ while (aFreq < tFreq && ge < alphaSize - 1)
+ {
+ aFreq += mtfFreq[++ge];
}
if (ge > gs && nPart != nGroups && nPart != 1
- && ((nGroups - nPart) % 2 == 1)) {
- aFreq -= mtfFreq[ge];
- ge--;
+ && ((nGroups - nPart) % 2 == 1))
+ {
+ aFreq -= mtfFreq[ge--];
}
- for (v = 0; v < alphaSize; v++) {
- if (v >= gs && v <= ge) {
- len[nPart - 1][v] = (char) LESSER_ICOST;
- } else {
- len[nPart - 1][v] = (char) GREATER_ICOST;
+ byte[] len_np = len[nPart - 1];
+ for (v = 0; v < alphaSize; v++)
+ {
+ if (v >= gs && v <= ge)
+ {
+ len_np[v] = LESSER_ICOST;
+ }
+ else
+ {
+ len_np[v] = GREATER_ICOST;
}
}
@@ -655,64 +679,76 @@ namespace Org.BouncyCastle.Apache.Bzip2
int[][] rfreq = CBZip2InputStream.InitIntArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
int[] fave = new int[BZip2Constants.N_GROUPS];
short[] cost = new short[BZip2Constants.N_GROUPS];
+ byte[] len_0 = len[0];
+ byte[] len_1 = len[1];
+ byte[] len_2 = len[2];
+ byte[] len_3 = len[3];
+ byte[] len_4 = len[4];
+ byte[] len_5 = len[5];
+
/*
Iterate up to N_ITERS times to improve the tables.
*/
- for (iter = 0; iter < BZip2Constants.N_ITERS; iter++) {
- for (t = 0; t < nGroups; t++) {
+ for (iter = 0; iter < BZip2Constants.N_ITERS; iter++)
+ {
+ for (t = 0; t < nGroups; t++)
+ {
fave[t] = 0;
- }
- for (t = 0; t < nGroups; t++) {
- for (v = 0; v < alphaSize; v++) {
- rfreq[t][v] = 0;
+ int[] rfreq_t = rfreq[t];
+ for (v = 0; v < alphaSize; v++)
+ {
+ rfreq_t[v] = 0;
}
}
nSelectors = 0;
gs = 0;
- while (true) {
-
+ while (gs < nMTF)
+ {
/* Set group start & end marks. */
- if (gs >= nMTF) {
- break;
- }
- ge = gs + BZip2Constants.G_SIZE - 1;
- if (ge >= nMTF) {
- ge = nMTF - 1;
- }
/*
- Calculate the cost of this group as coded
- by each of the coding tables.
- */
- for (t = 0; t < nGroups; t++) {
- cost[t] = 0;
- }
+ * Calculate the cost of this group as coded by each of the coding tables.
+ */
+
+ ge = System.Math.Min(gs + BZip2Constants.G_SIZE - 1, nMTF - 1);
+
+ if (nGroups == 6)
+ {
+ short cost0 = 0, cost1 = 0, cost2 = 0, cost3 = 0, cost4 = 0, cost5 = 0;
- if (nGroups == 6) {
- short cost0, cost1, cost2, cost3, cost4, cost5;
- cost0 = cost1 = cost2 = cost3 = cost4 = cost5 = 0;
- for (i = gs; i <= ge; i++) {
+ for (i = gs; i <= ge; i++)
+ {
int icv = szptr[i];
- cost0 += (short)len[0][icv];
- cost1 += (short)len[1][icv];
- cost2 += (short)len[2][icv];
- cost3 += (short)len[3][icv];
- cost4 += (short)len[4][icv];
- cost5 += (short)len[5][icv];
+ cost0 += len_0[icv];
+ cost1 += len_1[icv];
+ cost2 += len_2[icv];
+ cost3 += len_3[icv];
+ cost4 += len_4[icv];
+ cost5 += len_5[icv];
}
+
cost[0] = cost0;
cost[1] = cost1;
cost[2] = cost2;
cost[3] = cost3;
cost[4] = cost4;
cost[5] = cost5;
- } else {
- for (i = gs; i <= ge; i++) {
+ }
+ else
+ {
+ for (t = 0; t < nGroups; t++)
+ {
+ cost[t] = 0;
+ }
+
+ for (i = gs; i <= ge; i++)
+ {
int icv = szptr[i];
- for (t = 0; t < nGroups; t++) {
- cost[t] += (short)len[t][icv];
+ for (t = 0; t < nGroups; t++)
+ {
+ cost[t] += len[t][icv];
}
}
}
@@ -723,12 +759,14 @@ namespace Org.BouncyCastle.Apache.Bzip2
*/
bc = 999999999;
bt = -1;
- for (t = 0; t < nGroups; t++) {
- if (cost[t] < bc) {
+ for (t = 0; t < nGroups; t++)
+ {
+ if (cost[t] < bc)
+ {
bc = cost[t];
bt = t;
}
- };
+ }
fave[bt]++;
selector[nSelectors] = (char) bt;
nSelectors++;
@@ -736,8 +774,10 @@ namespace Org.BouncyCastle.Apache.Bzip2
/*
Increment the symbol frequencies for the selected table.
*/
- for (i = gs; i <= ge; i++) {
- rfreq[bt][szptr[i]]++;
+ int[] rfreq_bt = rfreq[bt];
+ for (i = gs; i <= ge; i++)
+ {
+ rfreq_bt[szptr[i]]++;
}
gs = ge + 1;
@@ -746,7 +786,8 @@ namespace Org.BouncyCastle.Apache.Bzip2
/*
Recompute the tables based on the accumulated frequencies.
*/
- for (t = 0; t < nGroups; t++) {
+ for (t = 0; t < nGroups; t++)
+ {
HbMakeCodeLengths(len[t], rfreq[t], alphaSize, 20);
}
}
@@ -755,54 +796,66 @@ namespace Org.BouncyCastle.Apache.Bzip2
fave = null;
cost = null;
- if (!(nGroups < 8)) {
+ if (!(nGroups < 8))
+ {
Panic();
}
- if (!(nSelectors < 32768 && nSelectors <= (2 + (900000 / BZip2Constants.G_SIZE)))) {
+ if (!(nSelectors < 32768 && nSelectors <= (2 + (900000 / BZip2Constants.G_SIZE))))
+ {
Panic();
}
-
/* Compute MTF values for the selectors. */
{
char[] pos = new char[BZip2Constants.N_GROUPS];
char ll_i, tmp2, tmp;
- for (i = 0; i < nGroups; i++) {
- pos[i] = (char) i;
+ for (i = 0; i < nGroups; i++)
+ {
+ pos[i] = (char)i;
}
- for (i = 0; i < nSelectors; i++) {
+ for (i = 0; i < nSelectors; i++)
+ {
ll_i = selector[i];
j = 0;
tmp = pos[j];
- while (ll_i != tmp) {
+ while (ll_i != tmp)
+ {
j++;
tmp2 = tmp;
tmp = pos[j];
pos[j] = tmp2;
}
pos[0] = tmp;
- selectorMtf[i] = (char) j;
+ selectorMtf[i] = (char)j;
}
}
int[][] code = CBZip2InputStream.InitIntArray(BZip2Constants.N_GROUPS, BZip2Constants.MAX_ALPHA_SIZE);
/* Assign actual codes for the tables. */
- for (t = 0; t < nGroups; t++) {
+ for (t = 0; t < nGroups; t++)
+ {
minLen = 32;
maxLen = 0;
- for (i = 0; i < alphaSize; i++) {
- if (len[t][i] > maxLen) {
- maxLen = len[t][i];
+ byte[] len_t = len[t];
+ for (i = 0; i < alphaSize; i++)
+ {
+ int lti = len_t[i];
+ if (lti > maxLen)
+ {
+ maxLen = lti;
}
- if (len[t][i] < minLen) {
- minLen = len[t][i];
+ if (lti < minLen)
+ {
+ minLen = lti;
}
}
- if (maxLen > 20) {
+ if (maxLen > 20)
+ {
Panic();
}
- if (minLen < 1) {
+ if (minLen < 1)
+ {
Panic();
}
HbAssignCodes(code[t], len[t], minLen, maxLen, alphaSize);
@@ -811,57 +864,73 @@ namespace Org.BouncyCastle.Apache.Bzip2
/* Transmit the mapping table. */
{
bool[] inUse16 = new bool[16];
- for (i = 0; i < 16; i++) {
+ for (i = 0; i < 16; i++)
+ {
inUse16[i] = false;
- for (j = 0; j < 16; j++) {
- if (inUse[i * 16 + j]) {
+ int i16 = i * 16;
+ for (j = 0; j < 16; j++)
+ {
+ if (inUse[i16 + j])
+ {
inUse16[i] = true;
+ break;
}
}
}
- for (i = 0; i < 16; i++) {
- if (inUse16[i]) {
- BsW(1, 1);
- } else {
- BsW(1, 0);
- }
+ for (i = 0; i < 16; i++)
+ {
+ BsW(1, inUse16[i] ? 1 : 0);
}
- for (i = 0; i < 16; i++) {
- if (inUse16[i]) {
- for (j = 0; j < 16; j++) {
- if (inUse[i * 16 + j]) {
- BsW(1, 1);
- } else {
- BsW(1, 0);
- }
+ for (i = 0; i < 16; i++)
+ {
+ if (inUse16[i])
+ {
+ int i16 = i * 16;
+ for (j = 0; j < 16; j++)
+ {
+ BsW(1, inUse[i16 + j] ? 1 : 0);
}
}
}
-
}
/* Now the selectors. */
BsW(3, nGroups);
BsW(15, nSelectors);
- for (i = 0; i < nSelectors; i++) {
- for (j = 0; j < selectorMtf[i]; j++) {
- BsW(1, 1);
+ for (i = 0; i < nSelectors; i++)
+ {
+ int count = selectorMtf[i];
+ //for (j = 0; j < count; j++)
+ //{
+ // BsW(1, 1);
+ //}
+ //BsW(1, 0);
+ while (count >= 24)
+ {
+ BsW(24, 0xFFFFFF);
+ count -= 24;
}
- BsW(1, 0);
+ BsW(count + 1, (1 << (count + 1)) - 2);
}
/* Now the coding tables. */
- for (t = 0; t < nGroups; t++) {
- int curr = len[t][0];
+ for (t = 0; t < nGroups; t++)
+ {
+ byte[] len_t = len[t];
+ int curr = len_t[0];
BsW(5, curr);
- for (i = 0; i < alphaSize; i++) {
- while (curr < len[t][i]) {
+ for (i = 0; i < alphaSize; i++)
+ {
+ int lti = len_t[i];
+ while (curr < lti)
+ {
BsW(2, 2);
curr++; /* 10 */
}
- while (curr > len[t][i]) {
+ while (curr > lti)
+ {
BsW(2, 3);
curr--; /* 11 */
}
@@ -872,28 +941,31 @@ namespace Org.BouncyCastle.Apache.Bzip2
/* And finally, the block data proper */
selCtr = 0;
gs = 0;
- while (true) {
- if (gs >= nMTF) {
- break;
- }
- ge = gs + BZip2Constants.G_SIZE - 1;
- if (ge >= nMTF) {
- ge = nMTF - 1;
- }
- for (i = gs; i <= ge; i++) {
- BsW(len[selector[selCtr]][szptr[i]],
- code[selector[selCtr]][szptr[i]]);
+ while (gs < nMTF)
+ {
+ ge = System.Math.Min(gs + BZip2Constants.G_SIZE - 1, nMTF - 1);
+
+ int selector_selCtr = selector[selCtr];
+ byte[] len_selCtr = len[selector_selCtr];
+ int[] code_selCtr = code[selector_selCtr];
+
+ for (i = gs; i <= ge; i++)
+ {
+ int sfmap_i = szptr[i];
+ BsW(len_selCtr[sfmap_i], code_selCtr[sfmap_i]);
}
gs = ge + 1;
selCtr++;
}
- if (!(selCtr == nSelectors)) {
+ if (!(selCtr == nSelectors))
+ {
Panic();
}
}
- private void MoveToFrontCodeAndSend() {
+ private void MoveToFrontCodeAndSend()
+ {
BsPutIntVS(24, origPtr);
GenerateMTFValues();
SendMTFValues();
@@ -901,101 +973,92 @@ namespace Org.BouncyCastle.Apache.Bzip2
private Stream bsStream;
- private void SimpleSort(int lo, int hi, int d) {
- int i, j, h, bigN, hp;
- int v;
+ private void SimpleSort(int lo, int hi, int d)
+ {
+ int i, j, h, v;
- bigN = hi - lo + 1;
- if (bigN < 2) {
+ int bigN = hi - lo + 1;
+ if (bigN < 2)
return;
- }
- hp = 0;
- while (incs[hp] < bigN) {
+ int hp = 0;
+ while (incs[hp] < bigN)
+ {
hp++;
}
hp--;
- for (; hp >= 0; hp--) {
+ for (; hp >= 0; hp--)
+ {
h = incs[hp];
i = lo + h;
- while (true) {
+ while (i <= hi)
+ {
/* copy 1 */
- if (i > hi) {
- break;
- }
v = zptr[i];
j = i;
- while (FullGtU(zptr[j - h] + d, v + d)) {
+ while (FullGtU(zptr[j - h] + d, v + d))
+ {
zptr[j] = zptr[j - h];
j = j - h;
- if (j <= (lo + h - 1)) {
+ if (j <= (lo + h - 1))
break;
- }
}
zptr[j] = v;
- i++;
/* copy 2 */
- if (i > hi) {
+ if (++i > hi)
break;
- }
+
v = zptr[i];
j = i;
- while (FullGtU(zptr[j - h] + d, v + d)) {
+ while (FullGtU(zptr[j - h] + d, v + d))
+ {
zptr[j] = zptr[j - h];
j = j - h;
- if (j <= (lo + h - 1)) {
+ if (j <= (lo + h - 1))
break;
- }
}
zptr[j] = v;
- i++;
/* copy 3 */
- if (i > hi) {
+ if (++i > hi)
break;
- }
+
v = zptr[i];
j = i;
- while (FullGtU(zptr[j - h] + d, v + d)) {
+ while (FullGtU(zptr[j - h] + d, v + d))
+ {
zptr[j] = zptr[j - h];
j = j - h;
- if (j <= (lo + h - 1)) {
+ if (j <= (lo + h - 1))
break;
- }
}
zptr[j] = v;
i++;
- if (workDone > workLimit && firstAttempt) {
+ if (workDone > workLimit && firstAttempt)
return;
- }
}
}
}
- private void Vswap(int p1, int p2, int n) {
- int temp = 0;
- while (n > 0) {
- temp = zptr[p1];
- zptr[p1] = zptr[p2];
- zptr[p2] = temp;
- p1++;
- p2++;
- n--;
+ private void Vswap(int p1, int p2, int n)
+ {
+ while (--n >= 0)
+ {
+ int t1 = zptr[p1], t2 = zptr[p2];
+ zptr[p1++] = t2;
+ zptr[p2++] = t1;
}
}
private int Med3(int a, int b, int c)
{
- if (a > b)
- {
- int t = a; a = b; b = t;
- }
-
- return c < a ? a : c > b ? b : c;
+ return a > b
+ ? (c < b ? b : c > a ? a : c)
+ : (c < a ? a : c > b ? b : c);
}
internal class StackElem
@@ -1041,9 +1104,8 @@ namespace Org.BouncyCastle.Apache.Bzip2
{
SimpleSort(lo, hi, d);
if (stackCount < 1 || (workDone > workLimit && firstAttempt))
- {
return;
- }
+
stackElem = (StackElem)stack[--stackCount];
lo = stackElem.ll;
hi = stackElem.hh;
@@ -1051,80 +1113,72 @@ namespace Org.BouncyCastle.Apache.Bzip2
continue;
}
- int med = Med3(blockBytes[zptr[lo] + d + 1],
- blockBytes[zptr[hi] + d + 1],
- blockBytes[zptr[(lo + hi) >> 1] + d + 1]);
+ int d1 = d + 1;
+ int med = Med3(
+ blockBytes[zptr[lo] + d1],
+ blockBytes[zptr[hi] + d1],
+ blockBytes[zptr[(lo + hi) >> 1] + d1]);
unLo = ltLo = lo;
unHi = gtHi = hi;
- while (true) {
- while (true) {
- if (unLo > unHi) {
+ while (true)
+ {
+ while (unLo <= unHi)
+ {
+ int zUnLo = zptr[unLo];
+ n = blockBytes[zUnLo + d1] - med;
+ if (n > 0)
break;
- }
- n = (int)blockBytes[zptr[unLo] + d + 1] - med;
- if (n == 0) {
- int temp = 0;
- temp = zptr[unLo];
+
+ if (n == 0)
+ {
zptr[unLo] = zptr[ltLo];
- zptr[ltLo] = temp;
- ltLo++;
- unLo++;
- continue;
- };
- if (n > 0) {
- break;
+ zptr[ltLo++] = zUnLo;
}
unLo++;
}
- while (true) {
- if (unLo > unHi) {
+ while (unLo <= unHi)
+ {
+ int zUnHi = zptr[unHi];
+ n = blockBytes[zUnHi + d1] - med;
+ if (n < 0)
break;
- }
- n = (int)blockBytes[zptr[unHi] + d + 1] - med;
- if (n == 0) {
- int temp = 0;
- temp = zptr[unHi];
+
+ if (n == 0)
+ {
zptr[unHi] = zptr[gtHi];
- zptr[gtHi] = temp;
- gtHi--;
- unHi--;
- continue;
- };
- if (n < 0) {
- break;
+ zptr[gtHi--] = zUnHi;
}
unHi--;
}
- if (unLo > unHi) {
+ if (unLo > unHi)
break;
- }
- int tempx = zptr[unLo];
- zptr[unLo] = zptr[unHi];
- zptr[unHi] = tempx;
- unLo++;
- unHi--;
+
+ int temp = zptr[unLo];
+ zptr[unLo++] = zptr[unHi];
+ zptr[unHi--] = temp;
}
if (gtHi < ltLo)
{
- ++d;
+ d = d1;
continue;
}
- n = ((ltLo - lo) < (unLo - ltLo)) ? (ltLo - lo) : (unLo - ltLo);
+ n = System.Math.Min(ltLo - lo, unLo - ltLo);
Vswap(lo, unLo - n, n);
- m = ((hi - gtHi) < (gtHi - unHi)) ? (hi - gtHi) : (gtHi - unHi);
+
+ m = System.Math.Min(hi - gtHi, gtHi - unHi);
Vswap(unLo, hi - m + 1, m);
- n = lo + unLo - ltLo - 1;
- m = hi - (gtHi - unHi) + 1;
+ n = lo + (unLo - ltLo);
+ m = hi - (gtHi - unHi);
- PushStackElem(stack, stackCount++, lo, n, d);
- PushStackElem(stack, stackCount++, n + 1, m - 1, d + 1);
+ PushStackElem(stack, stackCount++, lo, n - 1, d);
+ PushStackElem(stack, stackCount++, n, m, d1);
- lo = m;
+ lo = m + 1;
}
}
@@ -1141,8 +1195,6 @@ namespace Org.BouncyCastle.Apache.Bzip2
from 0 to last+NUM_OVERSHOOT_BYTES inclusive. First,
set up the overshoot area for block.
*/
-
- // if (verbosity >= 4) fprintf ( stderr, " sort initialise ...\n" );
for (i = 0; i < BZip2Constants.NUM_OVERSHOOT_BYTES; i++)
{
blockBytes[count + i + 1] = blockBytes[(i % count) + 1];
@@ -1181,16 +1233,16 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
c1 = blockBytes[0];
- for (i = 0; i < count; i++)
+ for (i = 1; i <= count; i++)
{
- c2 = blockBytes[i + 1];
+ c2 = blockBytes[i];
ftab[(c1 << 8) + c2]++;
c1 = c2;
}
- for (i = 1; i <= 65536; i++)
+ for (i = 0; i < 65536; i++)
{
- ftab[i] += ftab[i - 1];
+ ftab[i + 1] += ftab[i];
}
c1 = blockBytes[1];
@@ -1219,36 +1271,38 @@ namespace Org.BouncyCastle.Apache.Bzip2
}
{
- int vv;
int h = 1;
- do {
+ do
+ {
h = 3 * h + 1;
}
while (h <= 256);
- do {
+ do
+ {
h = h / 3;
- for (i = h; i <= 255; i++) {
- vv = runningOrder[i];
+ for (i = h; i <= 255; i++)
+ {
+ int vv = runningOrder[i];
j = i;
- while ((ftab[((runningOrder[j - h]) + 1) << 8]
- - ftab[(runningOrder[j - h]) << 8]) >
- (ftab[((vv) + 1) << 8] - ftab[(vv) << 8])) {
+ while ((ftab[(runningOrder[j - h] + 1) << 8] - ftab[runningOrder[j - h] << 8])
+ > (ftab[(vv + 1) << 8] - ftab[vv << 8]))
+ {
runningOrder[j] = runningOrder[j - h];
j = j - h;
- if (j <= (h - 1)) {
+ if (j < h)
break;
- }
}
runningOrder[j] = vv;
}
- } while (h != 1);
+ }
+ while (h != 1);
}
/*
The main sorting loop.
*/
- for (i = 0; i <= 255; i++) {
-
+ for (i = 0; i <= 255; i++)
+ {
/*
Process big buckets, starting with the least full.
*/
@@ -1261,16 +1315,18 @@ namespace Org.BouncyCastle.Apache.Bzip2
completed many of the small buckets [ss, j], so
we don't have to sort them at all.
*/
- for (j = 0; j <= 255; j++) {
+ for (j = 0; j <= 255; j++)
+ {
sb = (ss << 8) + j;
- if (!((ftab[sb] & SETMASK) == SETMASK)) {
+ if ((ftab[sb] & SETMASK) != SETMASK)
+ {
int lo = ftab[sb] & CLEARMASK;
int hi = (ftab[sb + 1] & CLEARMASK) - 1;
- if (hi > lo) {
+ if (hi > lo)
+ {
QSort3(lo, hi, 2);
- if (workDone > workLimit && firstAttempt) {
+ if (workDone > workLimit && firstAttempt)
return;
- }
}
ftab[sb] |= SETMASK;
}
@@ -1288,10 +1344,10 @@ namespace Org.BouncyCastle.Apache.Bzip2
if (i < 255)
{
- int bbStart = ftab[ss << 8] & CLEARMASK;
- int bbSize = (ftab[(ss + 1) << 8] & CLEARMASK) - bbStart;
- int shifts = 0;
+ int bbStart = ftab[ss << 8] & CLEARMASK;
+ int bbSize = (ftab[(ss + 1) << 8] & CLEARMASK) - bbStart;
+ int shifts = 0;
while ((bbSize >> shifts) > 65534)
{
shifts++;
@@ -1318,17 +1374,19 @@ namespace Org.BouncyCastle.Apache.Bzip2
Now scan this big bucket so as to synthesise the
sorted order for small buckets [t, ss] for all t != ss.
*/
- for (j = 0; j <= 255; j++) {
+ for (j = 0; j <= 255; j++)
+ {
copy[j] = ftab[(j << 8) + ss] & CLEARMASK;
}
for (j = ftab[ss << 8] & CLEARMASK;
j < (ftab[(ss + 1) << 8] & CLEARMASK); j++)
{
- c1 = blockBytes[zptr[j]];
+ int zptr_j = zptr[j];
+ c1 = blockBytes[zptr_j];
if (!bigDone[c1])
{
- zptr[copy[c1]] = (zptr[j] == 0 ? count : zptr[j]) - 1;
+ zptr[copy[c1]] = (zptr_j == 0 ? count : zptr_j) - 1;
copy[c1]++;
}
}
@@ -1343,21 +1401,21 @@ namespace Org.BouncyCastle.Apache.Bzip2
private void RandomiseBlock()
{
- int i;
- int rNToGo = 0;
- int rTPos = 0;
- for (i = 0; i < 256; i++)
+ for (int i = 0; i < 256; i++)
{
inUse[i] = false;
}
- for (i = 0; i < count; i++)
+ int rNToGo = 0;
+ int rTPos = 0;
+
+ for (int i = 0; i < count; i++)
{
if (rNToGo == 0)
{
- rNToGo = (char) BZip2Constants.rNums[rTPos];
- rTPos++;
- if (rTPos == 512)
+ rNToGo = BZip2Constants.rNums[rTPos];
+
+ if (++rTPos == 512)
{
rTPos = 0;
}
@@ -1395,7 +1453,7 @@ namespace Org.BouncyCastle.Apache.Bzip2
origPtr = i;
break;
}
- };
+ }
if (origPtr == -1)
{
@@ -1505,9 +1563,8 @@ namespace Org.BouncyCastle.Apache.Bzip2
because the number of elems to sort is
usually small, typically <= 20.
*/
- private int[] incs = { 1, 4, 13, 40, 121, 364, 1093, 3280,
- 9841, 29524, 88573, 265720,
- 797161, 2391484 };
+ private static readonly int[] incs = { 1, 4, 13, 40, 121, 364, 1093, 3280, 9841, 29524, 88573, 265720, 797161,
+ 2391484 };
private void AllocateCompressStructures()
{
@@ -1638,53 +1695,52 @@ namespace Org.BouncyCastle.Apache.Bzip2
nMTF = wr;
}
- public override int Read(byte[] buffer, int offset, int count) {
+ public override int Read(byte[] buffer, int offset, int count)
+ {
return 0;
}
-
- public override long Seek(long offset, SeekOrigin origin) {
+
+ public override long Seek(long offset, SeekOrigin origin)
+ {
return 0;
}
-
- public override void SetLength(long value) {
+
+ public override void SetLength(long value)
+ {
}
-
- public override void Write(byte[] buffer, int offset, int count) {
- for (int k = 0; k < count; ++k) {
+
+ public override void Write(byte[] buffer, int offset, int count)
+ {
+ for (int k = 0; k < count; ++k)
+ {
WriteByte(buffer[k + offset]);
}
}
-
- public override bool CanRead {
- get {
- return false;
- }
+
+ public override bool CanRead
+ {
+ get { return false; }
}
-
- public override bool CanSeek {
- get {
- return false;
- }
+
+ public override bool CanSeek
+ {
+ get { return false; }
}
-
- public override bool CanWrite {
- get {
- return true;
- }
+
+ public override bool CanWrite
+ {
+ get { return true; }
}
-
- public override long Length {
- get {
- return 0;
- }
+
+ public override long Length
+ {
+ get { return 0; }
}
-
- public override long Position {
- get {
- return 0;
- }
- set {
- }
+
+ public override long Position
+ {
+ get { return 0; }
+ set {}
}
}
-}
\ No newline at end of file
+}
|
