ant-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dona...@apache.org
Subject cvs commit: jakarta-ant/proposal/myrmidon/src/java/org/apache/aut/bzip2 CBZip2OutputStream.java
Date Mon, 28 Jan 2002 09:57:54 GMT
donaldp     02/01/28 01:57:54

  Modified:    proposal/myrmidon/src/java/org/apache/aut/bzip2
                        CBZip2OutputStream.java
  Log:
  
  
  Revision  Changes    Path
  1.4       +333 -327  jakarta-ant/proposal/myrmidon/src/java/org/apache/aut/bzip2/CBZip2OutputStream.java
  
  Index: CBZip2OutputStream.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/proposal/myrmidon/src/java/org/apache/aut/bzip2/CBZip2OutputStream.java,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- CBZip2OutputStream.java	27 Jan 2002 03:16:03 -0000	1.3
  +++ CBZip2OutputStream.java	28 Jan 2002 09:57:53 -0000	1.4
  @@ -20,6 +20,8 @@
       extends OutputStream
       implements BZip2Constants
   {
  +    private final static int LOWER_BYTE_MASK = 0x000000ff;
  +    private final static int UPPER_BYTE_MASK = 0xffffff00;
       private final static int SETMASK = ( 1 << 21 );
       private final static int CLEARMASK = ( ~SETMASK );
       private final static int GREATER_ICOST = 15;
  @@ -41,18 +43,18 @@
   
       private boolean[] m_inUse = new boolean[ 256 ];
   
  -    private char[] seqToUnseq = new char[ 256 ];
  -    private char[] unseqToSeq = new char[ 256 ];
  +    private char[] m_seqToUnseq = new char[ 256 ];
  +    private char[] m_unseqToSeq = new char[ 256 ];
   
  -    private char[] selector = new char[ MAX_SELECTORS ];
  -    private char[] selectorMtf = new char[ MAX_SELECTORS ];
  +    private char[] m_selector = new char[ MAX_SELECTORS ];
  +    private char[] m_selectorMtf = new char[ MAX_SELECTORS ];
   
  -    private int[] mtfFreq = new int[ MAX_ALPHA_SIZE ];
  +    private int[] m_mtfFreq = new int[ MAX_ALPHA_SIZE ];
   
  -    private int currentChar = -1;
  -    private int runLength = 0;
  +    private int m_currentChar = -1;
  +    private int m_runLength;
   
  -    boolean closed = false;
  +    private boolean m_closed;
   
       /*
        * Knuth's increments seem to work better
  @@ -60,89 +62,86 @@
        * because the number of elems to sort is
        * usually small, typically <= 20.
        */
  -    private int[] incs = new int[]
  +    private int[] m_incs = new int[]
       {
           1, 4, 13, 40, 121, 364, 1093, 3280,
           9841, 29524, 88573, 265720,
           797161, 2391484
       };
   
  -    boolean blockRandomised;
  +    private boolean m_blockRandomised;
   
       /*
        * always: in the range 0 .. 9.
        * The current block size is 100000 * this number.
        */
  -    int blockSize100k;
  -    int bsBuff;
  -    int bsLive;
  +    private int m_blockSize100k;
  +    private int m_bsBuff;
  +    private int m_bsLive;
   
  -    int bytesIn;
  -    int bytesOut;
  +    private int m_bytesIn;
  +    private int m_bytesOut;
   
       /*
        * index of the last char in the block, so
        * the block size == last + 1.
        */
  -    int last;
  +    private int m_last;
   
       /*
        * index in zptr[] of original string after sorting.
        */
  -    int origPtr;
  +    private int m_origPtr;
   
  -    private int allowableBlockSize;
  +    private int m_allowableBlockSize;
   
  -    private char[] block;
  +    private char[] m_block;
   
  -    private int blockCRC, combinedCRC;
  +    private int m_blockCRC;
  +    private int m_combinedCRC;
   
  -    private OutputStream bsStream;
  -    private boolean firstAttempt;
  -    private int[] ftab;
  -    private int nBlocksRandomised;
  -    private int nInUse;
  +    private OutputStream m_bsStream;
  +    private boolean m_firstAttempt;
  +    private int[] m_ftab;
  +    private int m_nBlocksRandomised;
  +    private int m_nInUse;
   
  -    private int nMTF;
  -    private int[] quadrant;
  -    private short[] szptr;
  -    private int workDone;
  +    private int m_nMTF;
  +    private int[] m_quadrant;
  +    private short[] m_szptr;
  +    private int m_workDone;
   
       /*
        * Used when sorting.  If too many long comparisons
        * happen, we stop sorting, randomise the block
        * slightly, and try again.
        */
  -    private int workFactor;
  -    private int workLimit;
  -    private int[] zptr;
  +    private int m_workFactor;
  +    private int m_workLimit;
  +    private int[] m_zptr;
   
  -    public CBZip2OutputStream( OutputStream inStream )
  +    public CBZip2OutputStream( final OutputStream output )
           throws IOException
       {
  -        this( inStream, 9 );
  +        this( output, 9 );
       }
   
  -    public CBZip2OutputStream( OutputStream inStream, int inBlockSize )
  +    public CBZip2OutputStream( final OutputStream output, final int blockSize )
           throws IOException
       {
  -        block = null;
  -        quadrant = null;
  -        zptr = null;
  -        ftab = null;
  +        bsSetStream( output );
  +        m_workFactor = 50;
   
  -        bsSetStream( inStream );
  -
  -        workFactor = 50;
  -        if( inBlockSize > 9 )
  +        int outBlockSize = blockSize;
  +        if( outBlockSize > 9 )
           {
  -            inBlockSize = 9;
  +            outBlockSize = 9;
           }
  -        if( inBlockSize < 1 )
  +        if( outBlockSize < 1 )
           {
  -            inBlockSize = 1;
  +            outBlockSize = 1;
           }
  -        blockSize100k = inBlockSize;
  +        m_blockSize100k = outBlockSize;
           allocateCompressStructures();
           initialize();
           initBlock();
  @@ -189,12 +188,12 @@
           boolean tooLong;
   
           int[] heap = new int[ MAX_ALPHA_SIZE + 2 ];
  -        int[] weight = new int[ MAX_ALPHA_SIZE * 2 ];
  +        int[] weights = new int[ MAX_ALPHA_SIZE * 2 ];
           int[] parent = new int[ MAX_ALPHA_SIZE * 2 ];
   
           for( i = 0; i < alphaSize; i++ )
           {
  -            weight[ i + 1 ] = ( freq[ i ] == 0 ? 1 : freq[ i ] ) << 8;
  +            weights[ i + 1 ] = ( freq[ i ] == 0 ? 1 : freq[ i ] ) << 8;
           }
   
           while( true )
  @@ -203,7 +202,7 @@
               nHeap = 0;
   
               heap[ 0 ] = 0;
  -            weight[ 0 ] = 0;
  +            weights[ 0 ] = 0;
               parent[ 0 ] = -2;
   
               for( i = 1; i <= alphaSize; i++ )
  @@ -216,7 +215,7 @@
                       int tmp;
                       zz = nHeap;
                       tmp = heap[ zz ];
  -                    while( weight[ tmp ] < weight[ heap[ zz >> 1 ] ] )
  +                    while( weights[ tmp ] < weights[ heap[ zz >> 1 ] ] )
                       {
                           heap[ zz ] = heap[ zz >> 1 ];
                           zz >>= 1;
  @@ -248,11 +247,11 @@
                               break;
                           }
                           if( yy < nHeap &&
  -                            weight[ heap[ yy + 1 ] ] < weight[ heap[ yy ] ] )
  +                            weights[ heap[ yy + 1 ] ] < weights[ heap[ yy ] ] )
                           {
                               yy++;
                           }
  -                        if( weight[ tmp ] < weight[ heap[ yy ] ] )
  +                        if( weights[ tmp ] < weights[ heap[ yy ] ] )
                           {
                               break;
                           }
  @@ -278,11 +277,11 @@
                               break;
                           }
                           if( yy < nHeap &&
  -                            weight[ heap[ yy + 1 ] ] < weight[ heap[ yy ] ] )
  +                            weights[ heap[ yy + 1 ] ] < weights[ heap[ yy ] ] )
                           {
                               yy++;
                           }
  -                        if( weight[ tmp ] < weight[ heap[ yy ] ] )
  +                        if( weights[ tmp ] < weights[ heap[ yy ] ] )
                           {
                               break;
                           }
  @@ -294,12 +293,10 @@
                   nNodes++;
                   parent[ n1 ] = parent[ n2 ] = nNodes;
   
  -                weight[ nNodes ] = ( ( weight[ n1 ] & 0xffffff00 )
  -                    + ( weight[ n2 ] & 0xffffff00 ) )
  -                    | ( 1 + ( ( ( weight[ n1 ] & 0x000000ff ) >
  -                    ( weight[ n2 ] & 0x000000ff ) ) ?
  -                    ( weight[ n1 ] & 0x000000ff ) :
  -                    ( weight[ n2 ] & 0x000000ff ) ) );
  +                final int v1 = weights[ n1 ];
  +                final int v2 = weights[ n2 ];
  +                final int weight = calculateWeight( v1, v2 );
  +                weights[ nNodes ] = weight;
   
                   parent[ nNodes ] = -1;
                   nHeap++;
  @@ -309,7 +306,7 @@
                       int tmp = 0;
                       zz = nHeap;
                       tmp = heap[ zz ];
  -                    while( weight[ tmp ] < weight[ heap[ zz >> 1 ] ] )
  +                    while( weights[ tmp ] < weights[ heap[ zz >> 1 ] ] )
                       {
                           heap[ zz ] = heap[ zz >> 1 ];
                           zz >>= 1;
  @@ -346,13 +343,22 @@
   
               for( i = 1; i < alphaSize; i++ )
               {
  -                j = weight[ i ] >> 8;
  +                j = weights[ i ] >> 8;
                   j = 1 + ( j / 2 );
  -                weight[ i ] = j << 8;
  +                weights[ i ] = j << 8;
               }
           }
       }
   
  +    private static int calculateWeight( final int v1, final int v2 )
  +    {
  +        final int upper = ( v1 & UPPER_BYTE_MASK ) + ( v2 & UPPER_BYTE_MASK );
  +        final int v1Lower = ( v1 & LOWER_BYTE_MASK );
  +        final int v2Lower = ( v2 & LOWER_BYTE_MASK );
  +        final int nnnn = ( v1Lower > v2Lower ) ? v1Lower : v2Lower;
  +        return upper | ( 1 + nnnn );
  +    }
  +
       private static void panic()
       {
           System.out.println( "panic" );
  @@ -362,21 +368,21 @@
       public void close()
           throws IOException
       {
  -        if( closed )
  +        if( m_closed )
           {
               return;
           }
   
  -        if( runLength > 0 )
  +        if( m_runLength > 0 )
           {
               writeRun();
           }
  -        currentChar = -1;
  +        m_currentChar = -1;
           endBlock();
           endCompression();
  -        closed = true;
  +        m_closed = true;
           super.close();
  -        bsStream.close();
  +        m_bsStream.close();
       }
   
       public void finalize()
  @@ -389,7 +395,7 @@
           throws IOException
       {
           super.flush();
  -        bsStream.flush();
  +        m_bsStream.flush();
       }
   
       /**
  @@ -402,42 +408,42 @@
           throws IOException
       {
           int b = ( 256 + bv ) % 256;
  -        if( currentChar != -1 )
  +        if( m_currentChar != -1 )
           {
  -            if( currentChar == b )
  +            if( m_currentChar == b )
               {
  -                runLength++;
  -                if( runLength > 254 )
  +                m_runLength++;
  +                if( m_runLength > 254 )
                   {
                       writeRun();
  -                    currentChar = -1;
  -                    runLength = 0;
  +                    m_currentChar = -1;
  +                    m_runLength = 0;
                   }
               }
               else
               {
                   writeRun();
  -                runLength = 1;
  -                currentChar = b;
  +                m_runLength = 1;
  +                m_currentChar = b;
               }
           }
           else
           {
  -            currentChar = b;
  -            runLength++;
  +            m_currentChar = b;
  +            m_runLength++;
           }
       }
   
       private void allocateCompressStructures()
       {
  -        int n = BASE_BLOCK_SIZE * blockSize100k;
  -        block = new char[ ( n + 1 + NUM_OVERSHOOT_BYTES ) ];
  -        quadrant = new int[ ( n + NUM_OVERSHOOT_BYTES ) ];
  -        zptr = new int[ n ];
  -        ftab = new int[ 65537 ];
  +        int n = BASE_BLOCK_SIZE * m_blockSize100k;
  +        m_block = new char[ ( n + 1 + NUM_OVERSHOOT_BYTES ) ];
  +        m_quadrant = new int[ ( n + NUM_OVERSHOOT_BYTES ) ];
  +        m_zptr = new int[ n ];
  +        m_ftab = new int[ 65537 ];
   
  -        if( block == null || quadrant == null || zptr == null
  -            || ftab == null )
  +        if( m_block == null || m_quadrant == null || m_zptr == null
  +            || m_ftab == null )
           {
               //int totalDraw = (n + 1 + NUM_OVERSHOOT_BYTES) + (n + NUM_OVERSHOOT_BYTES) + n + 65537;
               //compressOutOfMemory ( totalDraw, n );
  @@ -455,26 +461,26 @@
            */
           //    szptr = zptr;
   
  -        szptr = new short[ 2 * n ];
  +        m_szptr = new short[ 2 * n ];
       }
   
       private void bsFinishedWithStream()
           throws IOException
       {
  -        while( bsLive > 0 )
  +        while( m_bsLive > 0 )
           {
  -            int ch = ( bsBuff >> 24 );
  +            int ch = ( m_bsBuff >> 24 );
               try
               {
  -                bsStream.write( ch );// write 8-bit
  +                m_bsStream.write( ch );// write 8-bit
               }
               catch( IOException e )
               {
                   throw e;
               }
  -            bsBuff <<= 8;
  -            bsLive -= 8;
  -            bytesOut++;
  +            m_bsBuff <<= 8;
  +            m_bsLive -= 8;
  +            m_bytesOut++;
           }
       }
   
  @@ -501,67 +507,67 @@
   
       private void bsSetStream( OutputStream f )
       {
  -        bsStream = f;
  -        bsLive = 0;
  -        bsBuff = 0;
  -        bytesOut = 0;
  -        bytesIn = 0;
  +        m_bsStream = f;
  +        m_bsLive = 0;
  +        m_bsBuff = 0;
  +        m_bytesOut = 0;
  +        m_bytesIn = 0;
       }
   
       private void bsW( int n, int v )
           throws IOException
       {
  -        while( bsLive >= 8 )
  +        while( m_bsLive >= 8 )
           {
  -            int ch = ( bsBuff >> 24 );
  +            int ch = ( m_bsBuff >> 24 );
               try
               {
  -                bsStream.write( ch );// write 8-bit
  +                m_bsStream.write( ch );// write 8-bit
               }
               catch( IOException e )
               {
                   throw e;
               }
  -            bsBuff <<= 8;
  -            bsLive -= 8;
  -            bytesOut++;
  +            m_bsBuff <<= 8;
  +            m_bsLive -= 8;
  +            m_bytesOut++;
           }
  -        bsBuff |= ( v << ( 32 - bsLive - n ) );
  -        bsLive += n;
  +        m_bsBuff |= ( v << ( 32 - m_bsLive - n ) );
  +        m_bsLive += n;
       }
   
       private void doReversibleTransformation()
       {
           int i;
   
  -        workLimit = workFactor * last;
  -        workDone = 0;
  -        blockRandomised = false;
  -        firstAttempt = true;
  +        m_workLimit = m_workFactor * m_last;
  +        m_workDone = 0;
  +        m_blockRandomised = false;
  +        m_firstAttempt = true;
   
           mainSort();
   
  -        if( workDone > workLimit && firstAttempt )
  +        if( m_workDone > m_workLimit && m_firstAttempt )
           {
               randomiseBlock();
  -            workLimit = workDone = 0;
  -            blockRandomised = true;
  -            firstAttempt = false;
  +            m_workLimit = m_workDone = 0;
  +            m_blockRandomised = true;
  +            m_firstAttempt = false;
               mainSort();
           }
   
  -        origPtr = -1;
  -        for( i = 0; i <= last; i++ )
  +        m_origPtr = -1;
  +        for( i = 0; i <= m_last; i++ )
           {
  -            if( zptr[ i ] == 0 )
  +            if( m_zptr[ i ] == 0 )
               {
  -                origPtr = i;
  +                m_origPtr = i;
                   break;
               }
           }
           ;
   
  -        if( origPtr == -1 )
  +        if( m_origPtr == -1 )
           {
               panic();
           }
  @@ -570,9 +576,9 @@
       private void endBlock()
           throws IOException
       {
  -        blockCRC = m_crc.getFinalCRC();
  -        combinedCRC = ( combinedCRC << 1 ) | ( combinedCRC >>> 31 );
  -        combinedCRC ^= blockCRC;
  +        m_blockCRC = m_crc.getFinalCRC();
  +        m_combinedCRC = ( m_combinedCRC << 1 ) | ( m_combinedCRC >>> 31 );
  +        m_combinedCRC ^= m_blockCRC;
   
           /*
            * sort the block and establish posn of original string
  @@ -602,15 +608,15 @@
           /*
            * Now the block's CRC, so it is in a known place.
            */
  -        bsPutint( blockCRC );
  +        bsPutint( m_blockCRC );
   
           /*
            * Now a single bit indicating randomisation.
            */
  -        if( blockRandomised )
  +        if( m_blockRandomised )
           {
               bsW( 1, 1 );
  -            nBlocksRandomised++;
  +            m_nBlocksRandomised++;
           }
           else
           {
  @@ -640,7 +646,7 @@
           bsPutUChar( 0x50 );
           bsPutUChar( 0x90 );
   
  -        bsPutint( combinedCRC );
  +        bsPutint( m_combinedCRC );
   
           bsFinishedWithStream();
       }
  @@ -653,8 +659,8 @@
           int s1;
           int s2;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -662,8 +668,8 @@
           i1++;
           i2++;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -671,8 +677,8 @@
           i1++;
           i2++;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -680,8 +686,8 @@
           i1++;
           i2++;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -689,8 +695,8 @@
           i1++;
           i2++;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -698,8 +704,8 @@
           i1++;
           i2++;
   
  -        c1 = block[ i1 + 1 ];
  -        c2 = block[ i2 + 1 ];
  +        c1 = m_block[ i1 + 1 ];
  +        c2 = m_block[ i2 + 1 ];
           if( c1 != c2 )
           {
               return ( c1 > c2 );
  @@ -707,18 +713,18 @@
           i1++;
           i2++;
   
  -        k = last + 1;
  +        k = m_last + 1;
   
           do
           {
  -            c1 = block[ i1 + 1 ];
  -            c2 = block[ i2 + 1 ];
  +            c1 = m_block[ i1 + 1 ];
  +            c2 = m_block[ i2 + 1 ];
               if( c1 != c2 )
               {
                   return ( c1 > c2 );
               }
  -            s1 = quadrant[ i1 ];
  -            s2 = quadrant[ i2 ];
  +            s1 = m_quadrant[ i1 ];
  +            s2 = m_quadrant[ i2 ];
               if( s1 != s2 )
               {
                   return ( s1 > s2 );
  @@ -726,14 +732,14 @@
               i1++;
               i2++;
   
  -            c1 = block[ i1 + 1 ];
  -            c2 = block[ i2 + 1 ];
  +            c1 = m_block[ i1 + 1 ];
  +            c2 = m_block[ i2 + 1 ];
               if( c1 != c2 )
               {
                   return ( c1 > c2 );
               }
  -            s1 = quadrant[ i1 ];
  -            s2 = quadrant[ i2 ];
  +            s1 = m_quadrant[ i1 ];
  +            s2 = m_quadrant[ i2 ];
               if( s1 != s2 )
               {
                   return ( s1 > s2 );
  @@ -741,14 +747,14 @@
               i1++;
               i2++;
   
  -            c1 = block[ i1 + 1 ];
  -            c2 = block[ i2 + 1 ];
  +            c1 = m_block[ i1 + 1 ];
  +            c2 = m_block[ i2 + 1 ];
               if( c1 != c2 )
               {
                   return ( c1 > c2 );
               }
  -            s1 = quadrant[ i1 ];
  -            s2 = quadrant[ i2 ];
  +            s1 = m_quadrant[ i1 ];
  +            s2 = m_quadrant[ i2 ];
               if( s1 != s2 )
               {
                   return ( s1 > s2 );
  @@ -756,14 +762,14 @@
               i1++;
               i2++;
   
  -            c1 = block[ i1 + 1 ];
  -            c2 = block[ i2 + 1 ];
  +            c1 = m_block[ i1 + 1 ];
  +            c2 = m_block[ i2 + 1 ];
               if( c1 != c2 )
               {
                   return ( c1 > c2 );
               }
  -            s1 = quadrant[ i1 ];
  -            s2 = quadrant[ i2 ];
  +            s1 = m_quadrant[ i1 ];
  +            s2 = m_quadrant[ i2 ];
               if( s1 != s2 )
               {
                   return ( s1 > s2 );
  @@ -771,21 +777,21 @@
               i1++;
               i2++;
   
  -            if( i1 > last )
  +            if( i1 > m_last )
               {
  -                i1 -= last;
  +                i1 -= m_last;
                   i1--;
               }
               ;
  -            if( i2 > last )
  +            if( i2 > m_last )
               {
  -                i2 -= last;
  +                i2 -= m_last;
                   i2--;
               }
               ;
   
               k -= 4;
  -            workDone++;
  +            m_workDone++;
           } while( k >= 0 );
   
           return false;
  @@ -803,25 +809,25 @@
           int EOB;
   
           makeMaps();
  -        EOB = nInUse + 1;
  +        EOB = m_nInUse + 1;
   
           for( i = 0; i <= EOB; i++ )
           {
  -            mtfFreq[ i ] = 0;
  +            m_mtfFreq[ i ] = 0;
           }
   
           wr = 0;
           zPend = 0;
  -        for( i = 0; i < nInUse; i++ )
  +        for( i = 0; i < m_nInUse; i++ )
           {
               yy[ i ] = (char)i;
           }
   
  -        for( i = 0; i <= last; i++ )
  +        for( i = 0; i <= m_last; i++ )
           {
               char ll_i;
   
  -            ll_i = unseqToSeq[ block[ zptr[ i ] ] ];
  +            ll_i = m_unseqToSeq[ m_block[ m_zptr[ i ] ] ];
   
               j = 0;
               tmp = yy[ j ];
  @@ -849,14 +855,14 @@
                           switch( zPend % 2 )
                           {
                               case 0:
  -                                szptr[ wr ] = (short)RUNA;
  +                                m_szptr[ wr ] = (short)RUNA;
                                   wr++;
  -                                mtfFreq[ RUNA ]++;
  +                                m_mtfFreq[ RUNA ]++;
                                   break;
                               case 1:
  -                                szptr[ wr ] = (short)RUNB;
  +                                m_szptr[ wr ] = (short)RUNB;
                                   wr++;
  -                                mtfFreq[ RUNB ]++;
  +                                m_mtfFreq[ RUNB ]++;
                                   break;
                           }
                           ;
  @@ -869,9 +875,9 @@
                       ;
                       zPend = 0;
                   }
  -                szptr[ wr ] = (short)( j + 1 );
  +                m_szptr[ wr ] = (short)( j + 1 );
                   wr++;
  -                mtfFreq[ j + 1 ]++;
  +                m_mtfFreq[ j + 1 ]++;
               }
           }
   
  @@ -883,14 +889,14 @@
                   switch( zPend % 2 )
                   {
                       case 0:
  -                        szptr[ wr ] = (short)RUNA;
  +                        m_szptr[ wr ] = (short)RUNA;
                           wr++;
  -                        mtfFreq[ RUNA ]++;
  +                        m_mtfFreq[ RUNA ]++;
                           break;
                       case 1:
  -                        szptr[ wr ] = (short)RUNB;
  +                        m_szptr[ wr ] = (short)RUNB;
                           wr++;
  -                        mtfFreq[ RUNB ]++;
  +                        m_mtfFreq[ RUNB ]++;
                           break;
                   }
                   if( zPend < 2 )
  @@ -901,11 +907,11 @@
               }
           }
   
  -        szptr[ wr ] = (short)EOB;
  +        m_szptr[ wr ] = (short)EOB;
           wr++;
  -        mtfFreq[ EOB ]++;
  +        m_mtfFreq[ EOB ]++;
   
  -        nMTF = wr;
  +        m_nMTF = wr;
       }
   
       private void hbAssignCodes( int[] code, char[] length, int minLen,
  @@ -935,7 +941,7 @@
       {
           //        blockNo++;
           m_crc.initialiseCRC();
  -        last = -1;
  +        m_last = -1;
           //        ch = 0;
   
           for( int i = 0; i < 256; i++ )
  @@ -946,24 +952,24 @@
           /*
            * 20 is just a paranoia constant
            */
  -        allowableBlockSize = BASE_BLOCK_SIZE * blockSize100k - 20;
  +        m_allowableBlockSize = BASE_BLOCK_SIZE * m_blockSize100k - 20;
       }
   
       private void initialize()
           throws IOException
       {
  -        bytesIn = 0;
  -        bytesOut = 0;
  -        nBlocksRandomised = 0;
  +        m_bytesIn = 0;
  +        m_bytesOut = 0;
  +        m_nBlocksRandomised = 0;
   
           /*
            * Write `magic' bytes h indicating file-format == huffmanised,
            * followed by a digit indicating blockSize100k.
            */
           bsPutUChar( 'h' );
  -        bsPutUChar( '0' + blockSize100k );
  +        bsPutUChar( '0' + m_blockSize100k );
   
  -        combinedCRC = 0;
  +        m_combinedCRC = 0;
       }
   
       private void mainSort()
  @@ -987,28 +993,28 @@
           //   if (verbosity >= 4) fprintf ( stderr, "        sort initialise ...\n" );
           for( i = 0; i < NUM_OVERSHOOT_BYTES; i++ )
           {
  -            block[ last + i + 2 ] = block[ ( i % ( last + 1 ) ) + 1 ];
  +            m_block[ m_last + i + 2 ] = m_block[ ( i % ( m_last + 1 ) ) + 1 ];
           }
  -        for( i = 0; i <= last + NUM_OVERSHOOT_BYTES; i++ )
  +        for( i = 0; i <= m_last + NUM_OVERSHOOT_BYTES; i++ )
           {
  -            quadrant[ i ] = 0;
  +            m_quadrant[ i ] = 0;
           }
   
  -        block[ 0 ] = (char)( block[ last + 1 ] );
  +        m_block[ 0 ] = (char)( m_block[ m_last + 1 ] );
   
  -        if( last < 4000 )
  +        if( m_last < 4000 )
           {
               /*
                * Use simpleSort(), since the full sorting mechanism
                * has quite a large constant overhead.
                */
  -            for( i = 0; i <= last; i++ )
  +            for( i = 0; i <= m_last; i++ )
               {
  -                zptr[ i ] = i;
  +                m_zptr[ i ] = i;
               }
  -            firstAttempt = false;
  -            workDone = workLimit = 0;
  -            simpleSort( 0, last, 0 );
  +            m_firstAttempt = false;
  +            m_workDone = m_workLimit = 0;
  +            simpleSort( 0, m_last, 0 );
           }
           else
           {
  @@ -1020,35 +1026,35 @@
   
               for( i = 0; i <= 65536; i++ )
               {
  -                ftab[ i ] = 0;
  +                m_ftab[ i ] = 0;
               }
   
  -            c1 = block[ 0 ];
  -            for( i = 0; i <= last; i++ )
  +            c1 = m_block[ 0 ];
  +            for( i = 0; i <= m_last; i++ )
               {
  -                c2 = block[ i + 1 ];
  -                ftab[ ( c1 << 8 ) + c2 ]++;
  +                c2 = m_block[ i + 1 ];
  +                m_ftab[ ( c1 << 8 ) + c2 ]++;
                   c1 = c2;
               }
   
               for( i = 1; i <= 65536; i++ )
               {
  -                ftab[ i ] += ftab[ i - 1 ];
  +                m_ftab[ i ] += m_ftab[ i - 1 ];
               }
   
  -            c1 = block[ 1 ];
  -            for( i = 0; i < last; i++ )
  +            c1 = m_block[ 1 ];
  +            for( i = 0; i < m_last; i++ )
               {
  -                c2 = block[ i + 2 ];
  +                c2 = m_block[ i + 2 ];
                   j = ( c1 << 8 ) + c2;
                   c1 = c2;
  -                ftab[ j ]--;
  -                zptr[ ftab[ j ] ] = i;
  +                m_ftab[ j ]--;
  +                m_zptr[ m_ftab[ j ] ] = i;
               }
   
  -            j = ( ( block[ last + 1 ] ) << 8 ) + ( block[ 1 ] );
  -            ftab[ j ]--;
  -            zptr[ ftab[ j ] ] = last;
  +            j = ( ( m_block[ m_last + 1 ] ) << 8 ) + ( m_block[ 1 ] );
  +            m_ftab[ j ]--;
  +            m_zptr[ m_ftab[ j ] ] = m_last;
   
               /*
                * Now ftab contains the first loc of every small bucket.
  @@ -1073,9 +1079,9 @@
                       {
                           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( ( m_ftab[ ( ( runningOrder[ j - h ] ) + 1 ) << 8 ]
  +                            - m_ftab[ ( runningOrder[ j - h ] ) << 8 ] ) >
  +                            ( m_ftab[ ( ( vv ) + 1 ) << 8 ] - m_ftab[ ( vv ) << 8 ] ) )
                           {
                               runningOrder[ j ] = runningOrder[ j - h ];
                               j = j - h;
  @@ -1110,20 +1116,20 @@
                   for( j = 0; j <= 255; j++ )
                   {
                       sb = ( ss << 8 ) + j;
  -                    if( !( ( ftab[ sb ] & SETMASK ) == SETMASK ) )
  +                    if( !( ( m_ftab[ sb ] & SETMASK ) == SETMASK ) )
                       {
  -                        int lo = ftab[ sb ] & CLEARMASK;
  -                        int hi = ( ftab[ sb + 1 ] & CLEARMASK ) - 1;
  +                        int lo = m_ftab[ sb ] & CLEARMASK;
  +                        int hi = ( m_ftab[ sb + 1 ] & CLEARMASK ) - 1;
                           if( hi > lo )
                           {
                               qSort3( lo, hi, 2 );
                               numQSorted += ( hi - lo + 1 );
  -                            if( workDone > workLimit && firstAttempt )
  +                            if( m_workDone > m_workLimit && m_firstAttempt )
                               {
                                   return;
                               }
                           }
  -                        ftab[ sb ] |= SETMASK;
  +                        m_ftab[ sb ] |= SETMASK;
                       }
                   }
   
  @@ -1139,8 +1145,8 @@
   
                   if( i < 255 )
                   {
  -                    int bbStart = ftab[ ss << 8 ] & CLEARMASK;
  -                    int bbSize = ( ftab[ ( ss + 1 ) << 8 ] & CLEARMASK ) - bbStart;
  +                    int bbStart = m_ftab[ ss << 8 ] & CLEARMASK;
  +                    int bbSize = ( m_ftab[ ( ss + 1 ) << 8 ] & CLEARMASK ) - bbStart;
                       int shifts = 0;
   
                       while( ( bbSize >> shifts ) > 65534 )
  @@ -1150,12 +1156,12 @@
   
                       for( j = 0; j < bbSize; j++ )
                       {
  -                        int a2update = zptr[ bbStart + j ];
  +                        int a2update = m_zptr[ bbStart + j ];
                           int qVal = ( j >> shifts );
  -                        quadrant[ a2update ] = qVal;
  +                        m_quadrant[ a2update ] = qVal;
                           if( a2update < NUM_OVERSHOOT_BYTES )
                           {
  -                            quadrant[ a2update + last + 1 ] = qVal;
  +                            m_quadrant[ a2update + m_last + 1 ] = qVal;
                           }
                       }
   
  @@ -1171,23 +1177,23 @@
                    */
                   for( j = 0; j <= 255; j++ )
                   {
  -                    copy[ j ] = ftab[ ( j << 8 ) + ss ] & CLEARMASK;
  +                    copy[ j ] = m_ftab[ ( j << 8 ) + ss ] & CLEARMASK;
                   }
   
  -                for( j = ftab[ ss << 8 ] & CLEARMASK;
  -                     j < ( ftab[ ( ss + 1 ) << 8 ] & CLEARMASK ); j++ )
  +                for( j = m_ftab[ ss << 8 ] & CLEARMASK;
  +                     j < ( m_ftab[ ( ss + 1 ) << 8 ] & CLEARMASK ); j++ )
                   {
  -                    c1 = block[ zptr[ j ] ];
  +                    c1 = m_block[ m_zptr[ j ] ];
                       if( !bigDone[ c1 ] )
                       {
  -                        zptr[ copy[ c1 ] ] = zptr[ j ] == 0 ? last : zptr[ j ] - 1;
  +                        m_zptr[ copy[ c1 ] ] = m_zptr[ j ] == 0 ? m_last : m_zptr[ j ] - 1;
                           copy[ c1 ]++;
                       }
                   }
   
                   for( j = 0; j <= 255; j++ )
                   {
  -                    ftab[ ( j << 8 ) + ss ] |= SETMASK;
  +                    m_ftab[ ( j << 8 ) + ss ] |= SETMASK;
                   }
               }
           }
  @@ -1196,14 +1202,14 @@
       private void makeMaps()
       {
           int i;
  -        nInUse = 0;
  +        m_nInUse = 0;
           for( i = 0; i < 256; i++ )
           {
               if( m_inUse[ i ] )
               {
  -                seqToUnseq[ nInUse ] = (char)i;
  -                unseqToSeq[ i ] = (char)nInUse;
  -                nInUse++;
  +                m_seqToUnseq[ m_nInUse ] = (char)i;
  +                m_unseqToSeq[ i ] = (char)m_nInUse;
  +                m_nInUse++;
               }
           }
       }
  @@ -1233,7 +1239,7 @@
       private void moveToFrontCodeAndSend()
           throws IOException
       {
  -        bsPutIntVS( 24, origPtr );
  +        bsPutIntVS( 24, m_origPtr );
           generateMTFValues();
           sendMTFValues();
       }
  @@ -1279,16 +1285,16 @@
               if( hi - lo < SMALL_THRESH || d > DEPTH_THRESH )
               {
                   simpleSort( lo, hi, d );
  -                if( workDone > workLimit && firstAttempt )
  +                if( m_workDone > m_workLimit && m_firstAttempt )
                   {
                       return;
                   }
                   continue;
               }
   
  -            med = med3( block[ zptr[ lo ] + d + 1 ],
  -                        block[ zptr[ hi ] + d + 1 ],
  -                        block[ zptr[ ( lo + hi ) >> 1 ] + d + 1 ] );
  +            med = med3( m_block[ m_zptr[ lo ] + d + 1 ],
  +                        m_block[ m_zptr[ hi ] + d + 1 ],
  +                        m_block[ m_zptr[ ( lo + hi ) >> 1 ] + d + 1 ] );
   
               unLo = ltLo = lo;
               unHi = gtHi = hi;
  @@ -1301,13 +1307,13 @@
                       {
                           break;
                       }
  -                    n = ( (int)block[ zptr[ unLo ] + d + 1 ] ) - med;
  +                    n = ( (int)m_block[ m_zptr[ unLo ] + d + 1 ] ) - med;
                       if( n == 0 )
                       {
                           int temp = 0;
  -                        temp = zptr[ unLo ];
  -                        zptr[ unLo ] = zptr[ ltLo ];
  -                        zptr[ ltLo ] = temp;
  +                        temp = m_zptr[ unLo ];
  +                        m_zptr[ unLo ] = m_zptr[ ltLo ];
  +                        m_zptr[ ltLo ] = temp;
                           ltLo++;
                           unLo++;
                           continue;
  @@ -1325,13 +1331,13 @@
                       {
                           break;
                       }
  -                    n = ( (int)block[ zptr[ unHi ] + d + 1 ] ) - med;
  +                    n = ( (int)m_block[ m_zptr[ unHi ] + d + 1 ] ) - med;
                       if( n == 0 )
                       {
                           int temp = 0;
  -                        temp = zptr[ unHi ];
  -                        zptr[ unHi ] = zptr[ gtHi ];
  -                        zptr[ gtHi ] = temp;
  +                        temp = m_zptr[ unHi ];
  +                        m_zptr[ unHi ] = m_zptr[ gtHi ];
  +                        m_zptr[ gtHi ] = temp;
                           gtHi--;
                           unHi--;
                           continue;
  @@ -1348,9 +1354,9 @@
                       break;
                   }
                   int temp = 0;
  -                temp = zptr[ unLo ];
  -                zptr[ unLo ] = zptr[ unHi ];
  -                zptr[ unHi ] = temp;
  +                temp = m_zptr[ unLo ];
  +                m_zptr[ unLo ] = m_zptr[ unHi ];
  +                m_zptr[ unHi ] = temp;
                   unLo++;
                   unHi--;
               }
  @@ -1399,7 +1405,7 @@
               m_inUse[ i ] = false;
           }
   
  -        for( i = 0; i <= last; i++ )
  +        for( i = 0; i <= m_last; i++ )
           {
               if( rNToGo == 0 )
               {
  @@ -1411,11 +1417,11 @@
                   }
               }
               rNToGo--;
  -            block[ i + 1 ] ^= ( ( rNToGo == 1 ) ? 1 : 0 );
  +            m_block[ i + 1 ] ^= ( ( rNToGo == 1 ) ? 1 : 0 );
               // handle 16 bit signed numbers
  -            block[ i + 1 ] &= 0xFF;
  +            m_block[ i + 1 ] &= 0xFF;
   
  -            m_inUse[ block[ i + 1 ] ] = true;
  +            m_inUse[ m_block[ i + 1 ] ] = true;
           }
       }
   
  @@ -1451,7 +1457,7 @@
           int nGroups;
           int nBytes;
   
  -        alphaSize = nInUse + 2;
  +        alphaSize = m_nInUse + 2;
           for( t = 0; t < N_GROUPS; t++ )
           {
               for( v = 0; v < alphaSize; v++ )
  @@ -1463,24 +1469,24 @@
           /*
            * Decide how many coding tables to use
            */
  -        if( nMTF <= 0 )
  +        if( m_nMTF <= 0 )
           {
               panic();
           }
   
  -        if( nMTF < 200 )
  +        if( m_nMTF < 200 )
           {
               nGroups = 2;
           }
  -        else if( nMTF < 600 )
  +        else if( m_nMTF < 600 )
           {
               nGroups = 3;
           }
  -        else if( nMTF < 1200 )
  +        else if( m_nMTF < 1200 )
           {
               nGroups = 4;
           }
  -        else if( nMTF < 2400 )
  +        else if( m_nMTF < 2400 )
           {
               nGroups = 5;
           }
  @@ -1498,7 +1504,7 @@
               int aFreq;
   
               nPart = nGroups;
  -            remF = nMTF;
  +            remF = m_nMTF;
               gs = 0;
               while( nPart > 0 )
               {
  @@ -1508,13 +1514,13 @@
                   while( aFreq < tFreq && ge < alphaSize - 1 )
                   {
                       ge++;
  -                    aFreq += mtfFreq[ ge ];
  +                    aFreq += m_mtfFreq[ ge ];
                   }
   
                   if( ge > gs && nPart != nGroups && nPart != 1
                       && ( ( nGroups - nPart ) % 2 == 1 ) )
                   {
  -                    aFreq -= mtfFreq[ ge ];
  +                    aFreq -= m_mtfFreq[ ge ];
                       ge--;
                   }
   
  @@ -1566,14 +1572,14 @@
                   /*
                    * Set group start & end marks.
                    */
  -                if( gs >= nMTF )
  +                if( gs >= m_nMTF )
                   {
                       break;
                   }
                   ge = gs + G_SIZE - 1;
  -                if( ge >= nMTF )
  +                if( ge >= m_nMTF )
                   {
  -                    ge = nMTF - 1;
  +                    ge = m_nMTF - 1;
                   }
   
                   /*
  @@ -1596,7 +1602,7 @@
                       cost0 = cost1 = cost2 = cost3 = cost4 = cost5 = 0;
                       for( i = gs; i <= ge; i++ )
                       {
  -                        short icv = szptr[ i ];
  +                        short icv = m_szptr[ i ];
                           cost0 += len[ 0 ][ icv ];
                           cost1 += len[ 1 ][ icv ];
                           cost2 += len[ 2 ][ icv ];
  @@ -1615,7 +1621,7 @@
                   {
                       for( i = gs; i <= ge; i++ )
                       {
  -                        short icv = szptr[ i ];
  +                        short icv = m_szptr[ i ];
                           for( t = 0; t < nGroups; t++ )
                           {
                               cost[ t ] += len[ t ][ icv ];
  @@ -1640,7 +1646,7 @@
                   ;
                   totc += bc;
                   fave[ bt ]++;
  -                selector[ nSelectors ] = (char)bt;
  +                m_selector[ nSelectors ] = (char)bt;
                   nSelectors++;
   
                   /*
  @@ -1648,7 +1654,7 @@
                    */
                   for( i = gs; i <= ge; i++ )
                   {
  -                    rfreq[ bt ][ szptr[ i ] ]++;
  +                    rfreq[ bt ][ m_szptr[ i ] ]++;
                   }
   
                   gs = ge + 1;
  @@ -1689,7 +1695,7 @@
               }
               for( i = 0; i < nSelectors; i++ )
               {
  -                ll_i = selector[ i ];
  +                ll_i = m_selector[ i ];
                   j = 0;
                   tmp = pos[ j ];
                   while( ll_i != tmp )
  @@ -1700,7 +1706,7 @@
                       pos[ j ] = tmp2;
                   }
                   pos[ 0 ] = tmp;
  -                selectorMtf[ i ] = (char)j;
  +                m_selectorMtf[ i ] = (char)j;
               }
           }
   
  @@ -1751,7 +1757,7 @@
                   }
               }
   
  -            nBytes = bytesOut;
  +            nBytes = m_bytesOut;
               for( i = 0; i < 16; i++ )
               {
                   if( inUse16[ i ] )
  @@ -1787,12 +1793,12 @@
           /*
            * Now the selectors.
            */
  -        nBytes = bytesOut;
  +        nBytes = m_bytesOut;
           bsW( 3, nGroups );
           bsW( 15, nSelectors );
           for( i = 0; i < nSelectors; i++ )
           {
  -            for( j = 0; j < selectorMtf[ i ]; j++ )
  +            for( j = 0; j < m_selectorMtf[ i ]; j++ )
               {
                   bsW( 1, 1 );
               }
  @@ -1802,7 +1808,7 @@
           /*
            * Now the coding tables.
            */
  -        nBytes = bytesOut;
  +        nBytes = m_bytesOut;
   
           for( t = 0; t < nGroups; t++ )
           {
  @@ -1833,24 +1839,24 @@
           /*
            * And finally, the block data proper
            */
  -        nBytes = bytesOut;
  +        nBytes = m_bytesOut;
           selCtr = 0;
           gs = 0;
           while( true )
           {
  -            if( gs >= nMTF )
  +            if( gs >= m_nMTF )
               {
                   break;
               }
               ge = gs + G_SIZE - 1;
  -            if( ge >= nMTF )
  +            if( ge >= m_nMTF )
               {
  -                ge = nMTF - 1;
  +                ge = m_nMTF - 1;
               }
               for( i = gs; i <= ge; i++ )
               {
  -                bsW( len[ selector[ selCtr ] ][ szptr[ i ] ],
  -                     code[ selector[ selCtr ] ][ szptr[ i ] ] );
  +                bsW( len[ m_selector[ selCtr ] ][ m_szptr[ i ] ],
  +                     code[ m_selector[ selCtr ] ][ m_szptr[ i ] ] );
               }
   
               gs = ge + 1;
  @@ -1878,7 +1884,7 @@
           }
   
           hp = 0;
  -        while( incs[ hp ] < bigN )
  +        while( m_incs[ hp ] < bigN )
           {
               hp++;
           }
  @@ -1886,7 +1892,7 @@
   
           for( ; hp >= 0; hp-- )
           {
  -            h = incs[ hp ];
  +            h = m_incs[ hp ];
   
               i = lo + h;
               while( true )
  @@ -1898,18 +1904,18 @@
                   {
                       break;
                   }
  -                v = zptr[ i ];
  +                v = m_zptr[ i ];
                   j = i;
  -                while( fullGtU( zptr[ j - h ] + d, v + d ) )
  +                while( fullGtU( m_zptr[ j - h ] + d, v + d ) )
                   {
  -                    zptr[ j ] = zptr[ j - h ];
  +                    m_zptr[ j ] = m_zptr[ j - h ];
                       j = j - h;
                       if( j <= ( lo + h - 1 ) )
                       {
                           break;
                       }
                   }
  -                zptr[ j ] = v;
  +                m_zptr[ j ] = v;
                   i++;
   
                   /*
  @@ -1919,18 +1925,18 @@
                   {
                       break;
                   }
  -                v = zptr[ i ];
  +                v = m_zptr[ i ];
                   j = i;
  -                while( fullGtU( zptr[ j - h ] + d, v + d ) )
  +                while( fullGtU( m_zptr[ j - h ] + d, v + d ) )
                   {
  -                    zptr[ j ] = zptr[ j - h ];
  +                    m_zptr[ j ] = m_zptr[ j - h ];
                       j = j - h;
                       if( j <= ( lo + h - 1 ) )
                       {
                           break;
                       }
                   }
  -                zptr[ j ] = v;
  +                m_zptr[ j ] = v;
                   i++;
   
                   /*
  @@ -1940,21 +1946,21 @@
                   {
                       break;
                   }
  -                v = zptr[ i ];
  +                v = m_zptr[ i ];
                   j = i;
  -                while( fullGtU( zptr[ j - h ] + d, v + d ) )
  +                while( fullGtU( m_zptr[ j - h ] + d, v + d ) )
                   {
  -                    zptr[ j ] = zptr[ j - h ];
  +                    m_zptr[ j ] = m_zptr[ j - h ];
                       j = j - h;
                       if( j <= ( lo + h - 1 ) )
                       {
                           break;
                       }
                   }
  -                zptr[ j ] = v;
  +                m_zptr[ j ] = v;
                   i++;
   
  -                if( workDone > workLimit && firstAttempt )
  +                if( m_workDone > m_workLimit && m_firstAttempt )
                   {
                       return;
                   }
  @@ -1967,9 +1973,9 @@
           int temp = 0;
           while( n > 0 )
           {
  -            temp = zptr[ p1 ];
  -            zptr[ p1 ] = zptr[ p2 ];
  -            zptr[ p2 ] = temp;
  +            temp = m_zptr[ p1 ];
  +            m_zptr[ p1 ] = m_zptr[ p2 ];
  +            m_zptr[ p2 ] = temp;
               p1++;
               p2++;
               n--;
  @@ -1979,45 +1985,45 @@
       private void writeRun()
           throws IOException
       {
  -        if( last < allowableBlockSize )
  +        if( m_last < m_allowableBlockSize )
           {
  -            m_inUse[ currentChar ] = true;
  -            for( int i = 0; i < runLength; i++ )
  +            m_inUse[ m_currentChar ] = true;
  +            for( int i = 0; i < m_runLength; i++ )
               {
  -                m_crc.updateCRC( (char)currentChar );
  +                m_crc.updateCRC( (char)m_currentChar );
               }
  -            switch( runLength )
  +            switch( m_runLength )
               {
                   case 1:
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
                       break;
                   case 2:
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
                       break;
                   case 3:
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
                       break;
                   default:
  -                    m_inUse[ runLength - 4 ] = true;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)currentChar;
  -                    last++;
  -                    block[ last + 1 ] = (char)( runLength - 4 );
  +                    m_inUse[ m_runLength - 4 ] = true;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)m_currentChar;
  +                    m_last++;
  +                    m_block[ m_last + 1 ] = (char)( m_runLength - 4 );
                       break;
               }
           }
  
  
  

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


Mime
View raw message