youys
/
ant
Not watched
1
0
Fork 1
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

Make Jikes less upset 

git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@278185 13f79535-47bb-0310-9956-ffa450edef68
master
Stefan Bodewig 20 years ago
parent
84c1b5f037
commit
e98db2e511
3 changed files with 315 additions and 315 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +115
    -115
      src/main/org/apache/tools/bzip2/CBZip2InputStream.java
  2. +196
    -196
      src/main/org/apache/tools/bzip2/CBZip2OutputStream.java
  3. +4
    -4
      src/main/org/apache/tools/bzip2/CRC.java

+ 115
- 115
src/main/org/apache/tools/bzip2/CBZip2InputStream.java View File

@@ -56,14 +56,14 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
final boolean[] inUse = this.data.inUse;
final byte[] seqToUnseq = this.data.seqToUnseq;

int nInUse = 0;
int nInUseShadow = 0;

for (int i = 0; i < 256; i++) {
if (inUse[i])
seqToUnseq[nInUse++] = (byte) i;
seqToUnseq[nInUseShadow++] = (byte) i;
}

this.nInUse = nInUse;
this.nInUse = nInUseShadow;
}

/**
@@ -317,11 +317,11 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
}

public void close() throws IOException {
InputStream in = this.in;
if (in != null) {
InputStream inShadow = this.in;
if (inShadow != null) {
try {
if (in != System.in) {
in.close();
if (inShadow != System.in) {
inShadow.close();
}
} finally {
this.data = null;
@@ -331,47 +331,47 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
}

private int bsR(final int n) throws IOException {
int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

if (bsLive < n) {
final InputStream in = this.in;
if (bsLiveShadow < n) {
final InputStream inShadow = this.in;
do {
int thech = in.read();
int thech = inShadow.read();

if (thech < 0) {
throw new IOException("unexpected end of stream");
}

bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
} while (bsLive < n);
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
} while (bsLiveShadow < n);

this.bsBuff = bsBuff;
this.bsBuff = bsBuffShadow;
}

this.bsLive = bsLive - n;
return (bsBuff >> (bsLive - n)) & ((1 << n) - 1);
this.bsLive = bsLiveShadow - n;
return (bsBuffShadow >> (bsLiveShadow - n)) & ((1 << n) - 1);
}

private boolean bsGetBit() throws IOException {
int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

if (bsLive < 1) {
if (bsLiveShadow < 1) {
int thech = this.in.read();

if (thech < 0) {
throw new IOException("unexpected end of stream");
}

bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
this.bsBuff = bsBuff;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
this.bsBuff = bsBuffShadow;
}

this.bsLive = bsLive - 1;
return ((bsBuff >> (bsLive - 1)) & 1) != 0;
this.bsLive = bsLiveShadow - 1;
return ((bsBuffShadow >> (bsLiveShadow - 1)) & 1) != 0;
}

private char bsGetUByte() throws IOException {
@@ -428,11 +428,11 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
}

private void recvDecodingTables() throws IOException {
final Data data = this.data;
final boolean[] inUse = data.inUse;
final byte[] pos = data.recvDecodingTables_pos;
final byte[] selector = data.selector;
final byte[] selectorMtf = data.selectorMtf;
final Data dataShadow = this.data;
final boolean[] inUse = dataShadow.inUse;
final byte[] pos = dataShadow.recvDecodingTables_pos;
final byte[] selector = dataShadow.selector;
final byte[] selectorMtf = dataShadow.selectorMtf;

int inUse16 = 0;

@@ -490,7 +490,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
selector[i] = tmp;
}

final char[][] len = data.temp_charArray2d;
final char[][] len = dataShadow.temp_charArray2d;

/* Now the coding tables */
for (int t = 0; t < nGroups; t++) {
@@ -513,12 +513,12 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
*/
private void createHuffmanDecodingTables(final int alphaSize,
final int nGroups) {
final Data data = this.data;
final char[][] len = data.temp_charArray2d;
final int[] minLens = data.minLens;
final int[][] limit = data.limit;
final int[][] base = data.base;
final int[][] perm = data.perm;
final Data dataShadow = this.data;
final char[][] len = dataShadow.temp_charArray2d;
final int[] minLens = dataShadow.minLens;
final int[][] limit = dataShadow.limit;
final int[][] base = dataShadow.base;
final int[][] perm = dataShadow.perm;

for (int t = 0; t < nGroups; t++) {
int minLen = 32;
@@ -543,17 +543,17 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
this.origPtr = bsR(24);
recvDecodingTables();

final InputStream in = this.in;
final Data data = this.data;
final byte[] ll8 = data.ll8;
final int[] unzftab = data.unzftab;
final byte[] selector = data.selector;
final byte[] seqToUnseq = data.seqToUnseq;
final char[] yy = data.getAndMoveToFrontDecode_yy;
final int[] minLens = data.minLens;
final int[][] limit = data.limit;
final int[][] base = data.base;
final int[][] perm = data.perm;
final InputStream inShadow = this.in;
final Data dataShadow = this.data;
final byte[] ll8 = dataShadow.ll8;
final int[] unzftab = dataShadow.unzftab;
final byte[] selector = dataShadow.selector;
final byte[] seqToUnseq = dataShadow.seqToUnseq;
final char[] yy = dataShadow.getAndMoveToFrontDecode_yy;
final int[] minLens = dataShadow.minLens;
final int[][] limit = dataShadow.limit;
final int[][] base = dataShadow.base;
final int[][] perm = dataShadow.perm;
final int limitLast = this.blockSize100k * 100000;

/*
@@ -571,9 +571,9 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
int groupPos = G_SIZE - 1;
final int eob = this.nInUse + 1;
int nextSym = getAndMoveToFrontDecode0(0);
int bsBuff = this.bsBuff;
int bsLive = this.bsLive;
int last = -1;
int bsBuffShadow = this.bsBuff;
int bsLiveShadow = this.bsLive;
int lastShadow = -1;
int zt = selector[groupNo] & 0xff;
int[] base_zt = base[zt];
int[] limit_zt = limit[zt];
@@ -608,33 +608,33 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {

// Inlined:
// int zvec = bsR(zn);
while (bsLive < zn) {
final int thech = in.read();
while (bsLiveShadow < zn) {
final int thech = inShadow.read();
if (thech >= 0) {
bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
continue;
} else {
throw new IOException("unexpected end of stream");
}
}
int zvec = (bsBuff >> (bsLive - zn)) & ((1 << zn) - 1);
bsLive -= zn;
int zvec = (bsBuffShadow >> (bsLiveShadow - zn)) & ((1 << zn) - 1);
bsLiveShadow -= zn;

while (zvec > limit_zt[zn]) {
zn++;
while (bsLive < 1) {
final int thech = in.read();
while (bsLiveShadow < 1) {
final int thech = inShadow.read();
if (thech >= 0) {
bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
continue;
} else {
throw new IOException("unexpected end of stream");
}
}
bsLive--;
zvec = (zvec << 1) | ((bsBuff >> bsLive) & 1);
bsLiveShadow--;
zvec = (zvec << 1) | ((bsBuffShadow >> bsLiveShadow) & 1);
}
nextSym = perm_zt[zvec - base_zt[zn]];
}
@@ -643,20 +643,20 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
unzftab[ch & 0xff] += s + 1;

while (s-- >= 0) {
ll8[++last] = ch;
ll8[++lastShadow] = ch;
}

if (last >= limitLast) {
if (lastShadow >= limitLast) {
throw new IOException("block overrun");
}
} else {
if (++last >= limitLast) {
if (++lastShadow >= limitLast) {
throw new IOException("block overrun");
}

final char tmp = yy[nextSym - 1];
unzftab[seqToUnseq[tmp] & 0xff]++;
ll8[last] = seqToUnseq[tmp];
ll8[lastShadow] = seqToUnseq[tmp];

/*
This loop is hammered during decompression,
@@ -688,75 +688,75 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {

// Inlined:
// int zvec = bsR(zn);
while (bsLive < zn) {
final int thech = in.read();
while (bsLiveShadow < zn) {
final int thech = inShadow.read();
if (thech >= 0) {
bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
continue;
} else {
throw new IOException("unexpected end of stream");
}
}
int zvec = (bsBuff >> (bsLive - zn)) & ((1 << zn) - 1);
bsLive -= zn;
int zvec = (bsBuffShadow >> (bsLiveShadow - zn)) & ((1 << zn) - 1);
bsLiveShadow -= zn;

while (zvec > limit_zt[zn]) {
zn++;
while (bsLive < 1) {
final int thech = in.read();
while (bsLiveShadow < 1) {
final int thech = inShadow.read();
if (thech >= 0) {
bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
continue;
} else {
throw new IOException("unexpected end of stream");
}
}
bsLive--;
zvec = (zvec << 1) | ((bsBuff >> bsLive) & 1);
bsLiveShadow--;
zvec = (zvec << 1) | ((bsBuffShadow >> bsLiveShadow) & 1);
}
nextSym = perm_zt[zvec - base_zt[zn]];
}
}

this.last = last;
this.bsLive = bsLive;
this.bsBuff = bsBuff;
this.last = lastShadow;
this.bsLive = bsLiveShadow;
this.bsBuff = bsBuffShadow;
}

private int getAndMoveToFrontDecode0(final int groupNo)
throws IOException {
final InputStream in = this.in;
final Data data = this.data;
final int zt = data.selector[groupNo] & 0xff;
final int[] limit_zt = data.limit[zt];
int zn = data.minLens[zt];
final InputStream inShadow = this.in;
final Data dataShadow = this.data;
final int zt = dataShadow.selector[groupNo] & 0xff;
final int[] limit_zt = dataShadow.limit[zt];
int zn = dataShadow.minLens[zt];
int zvec = bsR(zn);
int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

while (zvec > limit_zt[zn]) {
zn++;
while (bsLive < 1) {
final int thech = in.read();
while (bsLiveShadow < 1) {
final int thech = inShadow.read();

if (thech >= 0) {
bsBuff = (bsBuff << 8) | thech;
bsLive += 8;
bsBuffShadow = (bsBuffShadow << 8) | thech;
bsLiveShadow += 8;
continue;
} else {
throw new IOException("unexpected end of stream");
}
}
bsLive--;
zvec = (zvec << 1) | ((bsBuff >> bsLive) & 1);
bsLiveShadow--;
zvec = (zvec << 1) | ((bsBuffShadow >> bsLiveShadow) & 1);
}

this.bsLive = bsLive;
this.bsBuff = bsBuff;
this.bsLive = bsLiveShadow;
this.bsBuff = bsBuffShadow;

return data.perm[zt][zvec - data.base[zt][zn]];
return dataShadow.perm[zt][zvec - dataShadow.base[zt][zn]];
}

private void setupBlock() throws IOException {
@@ -775,7 +775,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
cftab[i] = c;
}

for (int i = 0, last = this.last; i <= last; i++) {
for (int i = 0, lastShadow = this.last; i <= lastShadow; i++) {
tt[cftab[ll8[i] & 0xff]++] = i;
}

@@ -800,7 +800,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
private void setupRandPartA() throws IOException {
if (this.su_i2 <= this.last) {
this.su_chPrev = this.su_ch2;
int su_ch2 = this.data.ll8[this.su_tPos] & 0xff;
int su_ch2Shadow = this.data.ll8[this.su_tPos] & 0xff;
this.su_tPos = this.data.tt[this.su_tPos];
if (this.su_rNToGo == 0) {
this.su_rNToGo = BZip2Constants.rNums[this.su_rTPos] - 1;
@@ -810,11 +810,11 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
} else {
this.su_rNToGo--;
}
this.su_ch2 = su_ch2 ^= (this.su_rNToGo == 1) ? 1 : 0;
this.su_ch2 = su_ch2Shadow ^= (this.su_rNToGo == 1) ? 1 : 0;
this.su_i2++;
this.currentChar = su_ch2;
this.currentChar = su_ch2Shadow;
this.currentState = RAND_PART_B_STATE;
this.crc.updateCRC(su_ch2);
this.crc.updateCRC(su_ch2Shadow);
} else {
endBlock();
initBlock();
@@ -825,13 +825,13 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
private void setupNoRandPartA() throws IOException {
if (this.su_i2 <= this.last) {
this.su_chPrev = this.su_ch2;
int su_ch2 = this.data.ll8[this.su_tPos] & 0xff;
this.su_ch2 = su_ch2;
int su_ch2Shadow = this.data.ll8[this.su_tPos] & 0xff;
this.su_ch2 = su_ch2Shadow;
this.su_tPos = this.data.tt[this.su_tPos];
this.su_i2++;
this.currentChar = su_ch2;
this.currentChar = su_ch2Shadow;
this.currentState = NO_RAND_PART_B_STATE;
this.crc.updateCRC(su_ch2);
this.crc.updateCRC(su_ch2Shadow);
} else {
this.currentState = NO_RAND_PART_A_STATE;
endBlock();
@@ -897,9 +897,9 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {

private void setupNoRandPartC() throws IOException {
if (this.su_j2 < this.su_z) {
int su_ch2 = this.su_ch2;
this.currentChar = su_ch2;
this.crc.updateCRC(su_ch2);
int su_ch2Shadow = this.su_ch2;
this.currentChar = su_ch2Shadow;
this.crc.updateCRC(su_ch2Shadow);
this.su_j2++;
this.currentState = NO_RAND_PART_C_STATE;
} else {
@@ -957,17 +957,17 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants {
* files.
*/
final int[] initTT(int length) {
int[] tt = this.tt;
int[] ttShadow = this.tt;

// tt.length should always be >= length, but theoretically
// it can happen, if the compressor mixed small and large
// blocks. Normally only the last block will be smaller
// than others.
if ((tt == null) || (tt.length < length)) {
this.tt = tt = new int[length];
if ((ttShadow == null) || (ttShadow.length < length)) {
this.tt = ttShadow = new int[length];
}

return tt;
return ttShadow;
}

}


+ 196
- 196
src/main/org/apache/tools/bzip2/CBZip2OutputStream.java View File

@@ -652,50 +652,50 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

private void writeRun() throws IOException {
final int last = this.last;
final int lastShadow = this.last;

if (last < this.allowableBlockSize) {
final int currentChar = this.currentChar;
final Data data = this.data;
data.inUse[currentChar] = true;
final byte ch = (byte) currentChar;
if (lastShadow < this.allowableBlockSize) {
final int currentCharShadow = this.currentChar;
final Data dataShadow = this.data;
dataShadow.inUse[currentCharShadow] = true;
final byte ch = (byte) currentCharShadow;

int runLength = this.runLength;
this.crc.updateCRC(currentChar, runLength);
int runLengthShadow = this.runLength;
this.crc.updateCRC(currentCharShadow, runLengthShadow);

switch (runLength) {
switch (runLengthShadow) {
case 1:
data.block[last + 2] = ch;
this.last = last + 1;
dataShadow.block[lastShadow + 2] = ch;
this.last = lastShadow + 1;
break;

case 2:
data.block[last + 2] = ch;
data.block[last + 3] = ch;
this.last = last + 2;
dataShadow.block[lastShadow + 2] = ch;
dataShadow.block[lastShadow + 3] = ch;
this.last = lastShadow + 2;
break;

case 3:
{
final byte[] block = data.block;
block[last + 2] = ch;
block[last + 3] = ch;
block[last + 4] = ch;
this.last = last + 3;
final byte[] block = dataShadow.block;
block[lastShadow + 2] = ch;
block[lastShadow + 3] = ch;
block[lastShadow + 4] = ch;
this.last = lastShadow + 3;
}
break;

default:
{
runLength -= 4;
data.inUse[runLength] = true;
final byte[] block = data.block;
block[last + 2] = ch;
block[last + 3] = ch;
block[last + 4] = ch;
block[last + 5] = ch;
block[last + 6] = (byte) runLength;
this.last = last + 5;
runLengthShadow -= 4;
dataShadow.inUse[runLengthShadow] = true;
final byte[] block = dataShadow.block;
block[lastShadow + 2] = ch;
block[lastShadow + 3] = ch;
block[lastShadow + 4] = ch;
block[lastShadow + 5] = ch;
block[lastShadow + 6] = (byte) runLengthShadow;
this.last = lastShadow + 5;
}
break;

@@ -716,8 +716,8 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

public void close() throws IOException {
OutputStream out = this.out;
if (out != null) {
OutputStream outShadow = this.out;
if (outShadow != null) {
try {
if (this.runLength > 0) {
writeRun();
@@ -725,7 +725,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
this.currentChar = -1;
endBlock();
endCompression();
out.close();
outShadow.close();
} finally {
this.out = null;
this.data = null;
@@ -734,9 +734,9 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

public void flush() throws IOException {
OutputStream out = this.out;
if (out != null) {
out.flush();
OutputStream outShadow = this.out;
if (outShadow != null) {
outShadow.flush();
}
}

@@ -914,18 +914,18 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

private void bsW(final int n, final int v) throws IOException {
final OutputStream out = this.out;
int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
final OutputStream outShadow = this.out;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}

this.bsBuff = bsBuff | (v << (32 - bsLive - n));
this.bsLive = bsLive + n;
this.bsBuff = bsBuffShadow | (v << (32 - bsLiveShadow - n));
this.bsLive = bsLiveShadow + n;
}

private void bsPutUByte(final int c) throws IOException {
@@ -1024,20 +1024,20 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

private int sendMTFValues1(final int nGroups, final int alphaSize) {
final Data data = this.data;
final int[][] rfreq = data.sendMTFValues_rfreq;
final int[] fave = data.sendMTFValues_fave;
final short[] cost = data.sendMTFValues_cost;
final char[] sfmap = data.sfmap;
final byte[] selector = data.selector;
final byte[][] len = data.sendMTFValues_len;
final Data dataShadow = this.data;
final int[][] rfreq = dataShadow.sendMTFValues_rfreq;
final int[] fave = dataShadow.sendMTFValues_fave;
final short[] cost = dataShadow.sendMTFValues_cost;
final char[] sfmap = dataShadow.sfmap;
final byte[] selector = dataShadow.selector;
final byte[][] len = dataShadow.sendMTFValues_len;
final byte[] len_0 = len[0];
final byte[] len_1 = len[1];
final byte[] len_2 = len[2];
final byte[] len_3 = len[3];
final byte[] len_4 = len[4];
final byte[] len_5 = len[5];
final int nMTF = this.nMTF;
final int nMTFShadow = this.nMTF;

int nSelectors = 0;

@@ -1060,7 +1060,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
by each of the coding tables.
*/

final int ge = Math.min(gs + G_SIZE - 1, nMTF - 1);
final int ge = Math.min(gs + G_SIZE - 1, nMTFShadow - 1);

if (nGroups == N_GROUPS) {
// unrolled version of the else-block
@@ -1144,15 +1144,15 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
private void sendMTFValues2(final int nGroups, final int nSelectors) {
// assert (nGroups < 8) : nGroups;

final Data data = this.data;
byte[] pos = data.sendMTFValues2_pos;
final Data dataShadow = this.data;
byte[] pos = dataShadow.sendMTFValues2_pos;

for (int i = nGroups; --i >= 0;) {
pos[i] = (byte) i;
}

for (int i = 0; i < nSelectors; i++) {
final byte ll_i = data.selector[i];
final byte ll_i = dataShadow.selector[i];
byte tmp = pos[0];
int j = 0;

@@ -1164,7 +1164,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

pos[0] = tmp;
data.selectorMtf[i] = (byte) j;
dataShadow.selectorMtf[i] = (byte) j;
}
}

@@ -1211,30 +1211,30 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
bsW(1, inUse16[i] ? 1 : 0);
}

final OutputStream out = this.out;
int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
final OutputStream outShadow = this.out;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

for (int i = 0; i < 16; i++) {
if (inUse16[i]) {
final int i16 = i * 16;
for (int j = 0; j < 16; j++) {
// inlined: bsW(1, inUse[i16 + j] ? 1 : 0);
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
if (inUse[i16 + j]) {
bsBuff |= 1 << (32 - bsLive - 1);
bsBuffShadow |= 1 << (32 - bsLiveShadow - 1);
}
bsLive++;
bsLiveShadow++;
}
}
}

this.bsBuff = bsBuff;
this.bsLive = bsLive;
this.bsBuff = bsBuffShadow;
this.bsLive = bsLiveShadow;
}

private void sendMTFValues5(final int nGroups, final int nSelectors)
@@ -1242,118 +1242,118 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
bsW(3, nGroups);
bsW(15, nSelectors);

final OutputStream out = this.out;
final OutputStream outShadow = this.out;
final byte[] selectorMtf = this.data.selectorMtf;

int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

for (int i = 0; i < nSelectors; i++) {
for (int j = 0, hj = selectorMtf[i] & 0xff; j < hj; j++) {
// inlined: bsW(1, 1);
while (bsLive >= 8) {
out.write(bsBuff >> 24);
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24);
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
bsBuff |= 1 << (32 - bsLive - 1);
bsLive++;
bsBuffShadow |= 1 << (32 - bsLiveShadow - 1);
bsLiveShadow++;
}

// inlined: bsW(1, 0);
while (bsLive >= 8) {
out.write(bsBuff >> 24);
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24);
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
//bsBuff |= 0 << (32 - bsLive - 1);
bsLive++;
//bsBuffShadow |= 0 << (32 - bsLiveShadow - 1);
bsLiveShadow++;
}

this.bsBuff = bsBuff;
this.bsLive = bsLive;
this.bsBuff = bsBuffShadow;
this.bsLive = bsLiveShadow;
}

private void sendMTFValues6(final int nGroups, final int alphaSize)
throws IOException {
final byte[][] len = this.data.sendMTFValues_len;
final OutputStream out = this.out;
final OutputStream outShadow = this.out;

int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

for (int t = 0; t < nGroups; t++) {
byte[] len_t = len[t];
int curr = len_t[0] & 0xff;

// inlined: bsW(5, curr);
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
bsBuff |= curr << (32 - bsLive - 5);
bsLive += 5;
bsBuffShadow |= curr << (32 - bsLiveShadow - 5);
bsLiveShadow += 5;

for (int i = 0; i < alphaSize; i++) {
int lti = len_t[i] & 0xff;
while (curr < lti) {
// inlined: bsW(2, 2);
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
bsBuff |= 2 << (32 - bsLive - 2);
bsLive += 2;
bsBuffShadow |= 2 << (32 - bsLiveShadow - 2);
bsLiveShadow += 2;

curr++; /* 10 */
}

while (curr > lti) {
// inlined: bsW(2, 3);
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
bsBuff |= 3 << (32 - bsLive - 2);
bsLive += 2;
bsBuffShadow |= 3 << (32 - bsLiveShadow - 2);
bsLiveShadow += 2;

curr--; /* 11 */
}

// inlined: bsW(1, 0);
while (bsLive >= 8) {
out.write(bsBuff >> 24); // write 8-bit
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24); // write 8-bit
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
// bsBuff |= 0 << (32 - bsLive - 1);
bsLive++;
// bsBuffShadow |= 0 << (32 - bsLiveShadow - 1);
bsLiveShadow++;
}
}

this.bsBuff = bsBuff;
this.bsLive = bsLive;
this.bsBuff = bsBuffShadow;
this.bsLive = bsLiveShadow;
}

private void sendMTFValues7(final int nSelectors) throws IOException {
final Data data = this.data;
final byte[][] len = data.sendMTFValues_len;
final int[][] code = data.sendMTFValues_code;
final OutputStream out = this.out;
final byte[] selector = data.selector;
final char[] sfmap = data.sfmap;
final int nMTF = this.nMTF;
final Data dataShadow = this.data;
final byte[][] len = dataShadow.sendMTFValues_len;
final int[][] code = dataShadow.sendMTFValues_code;
final OutputStream outShadow = this.out;
final byte[] selector = dataShadow.selector;
final char[] sfmap = dataShadow.sfmap;
final int nMTFShadow = this.nMTF;

int selCtr = 0;

int bsLive = this.bsLive;
int bsBuff = this.bsBuff;
int bsLiveShadow = this.bsLive;
int bsBuffShadow = this.bsBuff;

for (int gs = 0; gs < nMTF;) {
final int ge = Math.min(gs + G_SIZE - 1, nMTF - 1);
for (int gs = 0; gs < nMTFShadow;) {
final int ge = Math.min(gs + G_SIZE - 1, nMTFShadow - 1);
final int selector_selCtr = selector[selCtr] & 0xff;
final int[] code_selCtr = code[selector_selCtr];
final byte[] len_selCtr = len[selector_selCtr];
@@ -1365,14 +1365,14 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
// inlined: bsW(len_selCtr[sfmap_i] & 0xff,
// code_selCtr[sfmap_i]);
//
while (bsLive >= 8) {
out.write(bsBuff >> 24);
bsBuff <<= 8;
bsLive -= 8;
while (bsLiveShadow >= 8) {
outShadow.write(bsBuffShadow >> 24);
bsBuffShadow <<= 8;
bsLiveShadow -= 8;
}
final int n = len_selCtr[sfmap_i] & 0xFF;
bsBuff |= code_selCtr[sfmap_i] << (32 - bsLive - n);
bsLive += n;
bsBuffShadow |= code_selCtr[sfmap_i] << (32 - bsLiveShadow - n);
bsLiveShadow += n;

gs++;
}
@@ -1381,8 +1381,8 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
selCtr++;
}

this.bsBuff = bsBuff;
this.bsLive = bsLive;
this.bsBuff = bsBuffShadow;
this.bsLive = bsLiveShadow;
}

private void moveToFrontCodeAndSend() throws IOException {
@@ -1400,7 +1400,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
* HotSpot Client). Of course it depends on the JIT compiler of
* the vm.</p>
*/
private boolean mainSimpleSort(final Data data, final int lo, final int hi,
private boolean mainSimpleSort(final Data dataShadow, final int lo, final int hi,
final int d) {
final int bigN = hi - lo + 1;
if (bigN < 2) {
@@ -1412,14 +1412,14 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
hp++;
}

final int[] fmap = data.fmap;
final char[] quadrant = data.quadrant;
final byte[] block = data.block;
final int last = this.last;
final int lastPlus1 = last + 1;
final boolean firstAttempt = this.firstAttempt;
final int workLimit = this.workLimit;
int workDone = this.workDone;
final int[] fmap = dataShadow.fmap;
final char[] quadrant = dataShadow.quadrant;
final byte[] block = dataShadow.block;
final int lastShadow = this.last;
final int lastPlus1 = lastShadow + 1;
final boolean firstAttemptShadow = this.firstAttempt;
final int workLimitShadow = this.workLimit;
int workDoneShadow = this.workDone;

// Following block contains unrolled code which could be shortened by
// coding it in additional loops.
@@ -1437,7 +1437,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {

// for (int a;
// (j > mj) && mainGtU((a = fmap[j - h]) + d, vd,
// block, quadrant, last);
// block, quadrant, lastShadow);
// j -= h) {
// fmap[j] = a;
// }
@@ -1471,7 +1471,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
if (block[i1 + 5] == block[i2 + 5]) {
if (block[(i1 += 6)]
== block[(i2 += 6)]) {
int x = last;
int x = lastShadow;
X: while (x > 0) {
x -= 4;

@@ -1491,7 +1491,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
if ((i2 += 4) >= lastPlus1) {
i2 -= lastPlus1;
}
workDone++;
workDoneShadow++;
continue X;
} else if ((quadrant[i1 + 3] > quadrant[i2 + 3])) {
continue HAMMER;
@@ -1582,14 +1582,14 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
fmap[j] = v;
}

if (firstAttempt && (i <= hi) && (workDone > workLimit)) {
if (firstAttemptShadow && (i <= hi) && (workDoneShadow > workLimitShadow)) {
break HP;
}
}
}

this.workDone = workDone;
return firstAttempt && (workDone > workLimit);
this.workDone = workDoneShadow;
return firstAttemptShadow && (workDoneShadow > workLimitShadow);
}

private static void vswap(int[] fmap, int p1, int p2, int n) {
@@ -1623,7 +1623,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {

int[] fmap = this.data.fmap;
this.origPtr = -1;
for (int i = 0, last = this.last; i <= last; i++) {
for (int i = 0, lastShadow = this.last; i <= lastShadow; i++) {
if (fmap[i] == 0) {
this.origPtr = i;
break;
@@ -1636,13 +1636,13 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
/**
* Method "mainQSort3", file "blocksort.c", BZip2 1.0.2
*/
private void mainQSort3(final Data data, final int loSt, final int hiSt,
private void mainQSort3(final Data dataShadow, final int loSt, final int hiSt,
final int dSt) {
final int[] stack_ll = data.stack_ll;
final int[] stack_hh = data.stack_hh;
final int[] stack_dd = data.stack_dd;
final int[] fmap = data.fmap;
final byte[] block = data.block;
final int[] stack_ll = dataShadow.stack_ll;
final int[] stack_hh = dataShadow.stack_hh;
final int[] stack_dd = dataShadow.stack_dd;
final int[] fmap = dataShadow.fmap;
final byte[] block = dataShadow.block;

stack_ll[0] = loSt;
stack_hh[0] = hiSt;
@@ -1654,7 +1654,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
final int d = stack_dd[sp];

if ((hi - lo < SMALL_THRESH) || (d > DEPTH_THRESH)) {
if (mainSimpleSort(data, lo, hi, d)) {
if (mainSimpleSort(dataShadow, lo, hi, d)) {
return;
}
} else {
@@ -1743,17 +1743,17 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

private void mainSort() {
final Data data = this.data;
final int[] runningOrder = data.mainSort_runningOrder;
final int[] copy = data.mainSort_copy;
final boolean[] bigDone = data.mainSort_bigDone;
final int[] ftab = data.ftab;
final byte[] block = data.block;
final int[] fmap = data.fmap;
final char[] quadrant = data.quadrant;
final int last = this.last;
final int workLimit = this.workLimit;
final boolean firstAttempt = this.firstAttempt;
final Data dataShadow = this.data;
final int[] runningOrder = dataShadow.mainSort_runningOrder;
final int[] copy = dataShadow.mainSort_copy;
final boolean[] bigDone = dataShadow.mainSort_bigDone;
final int[] ftab = dataShadow.ftab;
final byte[] block = dataShadow.block;
final int[] fmap = dataShadow.fmap;
final char[] quadrant = dataShadow.quadrant;
final int lastShadow = this.last;
final int workLimitShadow = this.workLimit;
final boolean firstAttemptShadow = this.firstAttempt;

// Set up the 2-byte frequency table
for (int i = 65537; --i >= 0;) {
@@ -1766,17 +1766,17 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
set up the overshoot area for block.
*/
for (int i = 0; i < NUM_OVERSHOOT_BYTES; i++) {
block[last + i + 2] = block[(i % (last + 1)) + 1];
block[lastShadow + i + 2] = block[(i % (lastShadow + 1)) + 1];
}
for (int i = last + NUM_OVERSHOOT_BYTES; --i >= 0;) {
for (int i = lastShadow + NUM_OVERSHOOT_BYTES; --i >= 0;) {
quadrant[i] = 0;
}
block[0] = block[last + 1];
block[0] = block[lastShadow + 1];

// Complete the initial radix sort:

int c1 = block[0] & 0xff;
for (int i = 0; i <= last; i++) {
for (int i = 0; i <= lastShadow; i++) {
final int c2 = block[i + 1] & 0xff;
ftab[(c1 << 8) + c2]++;
c1 = c2;
@@ -1786,14 +1786,14 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
ftab[i] += ftab[i - 1];

c1 = block[1] & 0xff;
for (int i = 0; i < last; i++) {
for (int i = 0; i < lastShadow; i++) {
final int c2 = block[i + 2] & 0xff;
fmap[--ftab[(c1 << 8) + c2]] = i;
c1 = c2;
}

fmap[--ftab[((block[last + 1] & 0xff) << 8) + (block[1] & 0xff)]]
= last;
fmap[--ftab[((block[lastShadow + 1] & 0xff) << 8) + (block[1] & 0xff)]]
= lastShadow;

/*
Now ftab contains the first loc of every small bucket.
@@ -1849,8 +1849,8 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
final int lo = ftab_sb & CLEARMASK;
final int hi = (ftab[sb + 1] & CLEARMASK) - 1;
if (hi > lo) {
mainQSort3(data, lo, hi, 2);
if (firstAttempt && (this.workDone > workLimit)) {
mainQSort3(dataShadow, lo, hi, 2);
if (firstAttemptShadow && (this.workDone > workLimitShadow)) {
return;
}
}
@@ -1873,7 +1873,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
final int fmap_j = fmap[j];
c1 = block[fmap_j] & 0xff;
if (!bigDone[c1]) {
fmap[copy[c1]] = (fmap_j == 0) ? last : (fmap_j - 1);
fmap[copy[c1]] = (fmap_j == 0) ? lastShadow : (fmap_j - 1);
copy[c1]++;
}
}
@@ -1907,7 +1907,7 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
final char qVal = (char) (j >> shifts);
quadrant[a2update] = qVal;
if (a2update < NUM_OVERSHOOT_BYTES) {
quadrant[a2update + last + 1] = qVal;
quadrant[a2update + lastShadow + 1] = qVal;
}
}
}
@@ -1918,14 +1918,14 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
private void randomiseBlock() {
final boolean[] inUse = this.data.inUse;
final byte[] block = this.data.block;
final int last = this.last;
final int lastShadow = this.last;

for (int i = 256; --i >= 0;)
inUse[i] = false;

int rNToGo = 0;
int rTPos = 0;
for (int i = 0, j = 1; i <= last; i = j, j++) {
for (int i = 0, j = 1; i <= lastShadow; i = j, j++) {
if (rNToGo == 0) {
rNToGo = (char) BZip2Constants.rNums[rTPos];
if (++rTPos == 512) {
@@ -1944,40 +1944,40 @@ public class CBZip2OutputStream extends OutputStream implements BZip2Constants {
}

private void generateMTFValues() {
final int last = this.last;
final Data data = this.data;
final boolean[] inUse = data.inUse;
final byte[] block = data.block;
final int[] fmap = data.fmap;
final char[] sfmap = data.sfmap;
final int[] mtfFreq = data.mtfFreq;
final byte[] unseqToSeq = data.unseqToSeq;
final byte[] yy = data.generateMTFValues_yy;
final int lastShadow = this.last;
final Data dataShadow = this.data;
final boolean[] inUse = dataShadow.inUse;
final byte[] block = dataShadow.block;
final int[] fmap = dataShadow.fmap;
final char[] sfmap = dataShadow.sfmap;
final int[] mtfFreq = dataShadow.mtfFreq;
final byte[] unseqToSeq = dataShadow.unseqToSeq;
final byte[] yy = dataShadow.generateMTFValues_yy;

// make maps
int nInUse = 0;
int nInUseShadow = 0;
for (int i = 0; i < 256; i++) {
if (inUse[i]) {
unseqToSeq[i] = (byte) nInUse;
nInUse++;
unseqToSeq[i] = (byte) nInUseShadow;
nInUseShadow++;
}
}
this.nInUse = nInUse;
this.nInUse = nInUseShadow;

final int eob = nInUse + 1;
final int eob = nInUseShadow + 1;

for (int i = eob; i >= 0; i--) {
mtfFreq[i] = 0;
}

for (int i = nInUse; --i >= 0;) {
for (int i = nInUseShadow; --i >= 0;) {
yy[i] = (byte) i;
}

int wr = 0;
int zPend = 0;

for (int i = 0; i <= last; i++) {
for (int i = 0; i <= lastShadow; i++) {
final byte ll_i = unseqToSeq[block[fmap[i]] & 0xff];
byte tmp = yy[0];
int j = 0;


+ 4
- 4
src/main/org/apache/tools/bzip2/CRC.java View File

@@ -125,14 +125,14 @@ final class CRC {
}

void updateCRC(int inCh, int repeat) {
int globalCrc = this.globalCrc;
int globalCrcShadow = this.globalCrc;
while (repeat-- > 0) {
int temp = (globalCrc >> 24) ^ inCh;
globalCrc = (globalCrc << 8) ^ crc32Table[(temp >= 0)
int temp = (globalCrcShadow >> 24) ^ inCh;
globalCrcShadow = (globalCrcShadow << 8) ^ crc32Table[(temp >= 0)
? temp
: (temp + 256)];
}
this.globalCrc = globalCrc;
this.globalCrc = globalCrcShadow;
}

int globalCrc;


Write Preview
Loading…
Cancel
Save
Please read the following content carefully:

Dear OpenI User

Thank you for your continuous support to the Openl Qizhi Community AI Collaboration Platform. In order to protect your usage rights and ensure network security, we updated the Openl Qizhi Community AI Collaboration Platform Usage Agreement in January 2024. The updated agreement specifies that users are prohibited from using intranet penetration tools. After you click "Agree and continue", you can continue to use our services. Thank you for your cooperation and understanding.

For more agreement content, please refer to the《Openl Qizhi Community AI Collaboration Platform Usage Agreement》

Agree and continue
Disagree, exit