ant-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From bode...@apache.org
Subject cvs commit: ant/src/main/org/apache/tools/bzip2 CBZip2InputStream.java CBZip2OutputStream.java CRC.java
Date Tue, 26 Apr 2005 11:54:16 GMT
bodewig     2005/04/26 04:54:16

  Modified:    src/main/org/apache/tools/bzip2 CBZip2InputStream.java
                        CBZip2OutputStream.java CRC.java
  Log:
  Make Jikes less upset
  
  Revision  Changes    Path
  1.22      +115 -115  ant/src/main/org/apache/tools/bzip2/CBZip2InputStream.java
  
  Index: CBZip2InputStream.java
  ===================================================================
  RCS file: /home/cvs/ant/src/main/org/apache/tools/bzip2/CBZip2InputStream.java,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- CBZip2InputStream.java	14 Apr 2005 09:29:16 -0000	1.21
  +++ CBZip2InputStream.java	26 Apr 2005 11:54:15 -0000	1.22
  @@ -56,14 +56,14 @@
           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 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 @@
       }
   
       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 @@
       }
   
       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 @@
               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 @@
        */
       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 @@
           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 @@
           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 @@
   
                       // 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 @@
                   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 @@
   
                   // 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 @@
               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 @@
       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 @@
               } 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 @@
       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 @@
   
       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 @@
            * 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;
           }
   
       }
  
  
  
  1.24      +196 -196  ant/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java
  
  Index: CBZip2OutputStream.java
  ===================================================================
  RCS file: /home/cvs/ant/src/main/org/apache/tools/bzip2/CBZip2OutputStream.java,v
  retrieving revision 1.23
  retrieving revision 1.24
  diff -u -r1.23 -r1.24
  --- CBZip2OutputStream.java	14 Apr 2005 09:29:17 -0000	1.23
  +++ CBZip2OutputStream.java	26 Apr 2005 11:54:15 -0000	1.24
  @@ -652,50 +652,50 @@
       }
   
       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 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 @@
                   this.currentChar = -1;
                   endBlock();
                   endCompression();
  -                out.close();
  +                outShadow.close();
               } finally {
                   this.out = null;
                   this.data = null;
  @@ -734,9 +734,9 @@
       }
   
       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 @@
       }
   
       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 @@
       }
   
       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 @@
                     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 @@
       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 @@
               }
   
               pos[0] = tmp;
  -            data.selectorMtf[i] = (byte) j;
  +            dataShadow.selectorMtf[i] = (byte) j;
           }
       }
   
  @@ -1211,30 +1211,30 @@
               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 @@
           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 @@
                   // 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 @@
               selCtr++;
           }
   
  -        this.bsBuff = bsBuff;
  -        this.bsLive = bsLive;
  +        this.bsBuff = bsBuffShadow;
  +        this.bsLive = bsLiveShadow;
       }
   
       private void moveToFrontCodeAndSend() throws IOException {
  @@ -1400,7 +1400,7 @@
        * 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 @@
               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 @@
   
                       //  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 @@
                                           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 @@
                                                                                       if ((i2 += 4) >= lastPlus1) {
                                                                                           i2 -= lastPlus1;
                                                                                       }
  -                                                                                    workDone++;
  +                                                                                    workDoneShadow++;
                                                                                       continue X;
                                                                                   } else if ((quadrant[i1 + 3] > quadrant[i2 + 3])) {
                                                                                       continue HAMMER;
  @@ -1582,14 +1582,14 @@
                       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 @@
   
           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 @@
       /**
        * 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 @@
               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 @@
       }
   
       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 @@
             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 @@
               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 @@
                       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 @@
                   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 @@
                       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 @@
       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 @@
       }
   
       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;
  
  
  
  1.11      +4 -4      ant/src/main/org/apache/tools/bzip2/CRC.java
  
  Index: CRC.java
  ===================================================================
  RCS file: /home/cvs/ant/src/main/org/apache/tools/bzip2/CRC.java,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- CRC.java	14 Apr 2005 09:29:17 -0000	1.10
  +++ CRC.java	26 Apr 2005 11:54:15 -0000	1.11
  @@ -125,14 +125,14 @@
       }
   
       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;
  
  
  

---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@ant.apache.org
For additional commands, e-mail: dev-help@ant.apache.org


Mime
View raw message