ant-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sbaill...@apache.org
Subject cvs commit: jakarta-ant/src/main/org/apache/tools/tar TarInputStream.java
Date Wed, 09 Jan 2002 22:28:27 GMT
sbailliez    02/01/09 14:28:27

  Modified:    src/main/org/apache/tools/tar TarInputStream.java
  Log:
  - Incorrectly overload long skip(long) with void skip(int)
  - Code layout
  
  Revision  Changes    Path
  1.5       +108 -109  jakarta-ant/src/main/org/apache/tools/tar/TarInputStream.java
  
  Index: TarInputStream.java
  ===================================================================
  RCS file: /home/cvs/jakarta-ant/src/main/org/apache/tools/tar/TarInputStream.java,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- TarInputStream.java	28 Oct 2001 21:31:01 -0000	1.4
  +++ TarInputStream.java	9 Jan 2002 22:28:27 -0000	1.5
  @@ -53,15 +53,15 @@
    */
   
   /*
  - * This package is based on the work done by Timothy Gerard Endres 
  + * This package is based on the work done by Timothy Gerard Endres
    * (time@ice.com) to whom the Ant project is very grateful for his great code.
    */
   
   package org.apache.tools.tar;
   
   import java.io.FilterInputStream;
  -import java.io.InputStream;
   import java.io.IOException;
  +import java.io.InputStream;
   import java.io.OutputStream;
   
   /**
  @@ -69,20 +69,20 @@
    * methods are provided to position at each successive entry in
    * the archive, and the read each entry as a normal input stream
    * using read().
  - * 
  + *
    * @author Timothy Gerard Endres <a href="mailto:time@ice.com">time@ice.com</a>
    * @author Stefano Mazzocchi <a href="mailto:stefano@apache.org">stefano@apache.org</a>
    */
   public class TarInputStream extends FilterInputStream {
  -    
  -    protected boolean      debug;
  -    protected boolean      hasHitEOF;
  -    protected int          entrySize;
  -    protected int          entryOffset;
  -    protected byte[]       oneBuf;
  -    protected byte[]       readBuf;
  -    protected TarBuffer    buffer;
  -    protected TarEntry     currEntry;
  +
  +    protected boolean debug;
  +    protected boolean hasHitEOF;
  +    protected int entrySize;
  +    protected int entryOffset;
  +    protected byte[] oneBuf;
  +    protected byte[] readBuf;
  +    protected TarBuffer buffer;
  +    protected TarEntry currEntry;
   
       public TarInputStream(InputStream is) {
           this(is, TarBuffer.DEFAULT_BLKSIZE, TarBuffer.DEFAULT_RCDSIZE);
  @@ -104,29 +104,29 @@
   
       /**
        * Sets the debugging flag.
  -     * 
  +     *
        * @param debugF True to turn on debugging.
        */
       public void setDebug(boolean debug) {
           this.debug = debug;
           this.buffer.setDebug(debug);
  -    } 
  +    }
   
       /**
        * Closes this stream. Calls the TarBuffer's close() method.
        */
       public void close() throws IOException {
           this.buffer.close();
  -    } 
  +    }
   
       /**
        * Get the record size being used by this stream's TarBuffer.
  -     * 
  +     *
        * @return The TarBuffer record size.
        */
       public int getRecordSize() {
           return this.buffer.getRecordSize();
  -    } 
  +    }
   
       /**
        * Get the available data that can be read from the current
  @@ -134,63 +134,62 @@
        * is left in the entire archive, only in the current entry.
        * This value is determined from the entry's size header field
        * and the amount of data already read from the current entry.
  -     * 
  -     * 
  +     *
  +     *
        * @return The number of available bytes for the current entry.
        */
       public int available() throws IOException {
           return this.entrySize - this.entryOffset;
  -    } 
  +    }
   
       /**
        * Skip bytes in the input buffer. This skips bytes in the
        * current entry's data, not the entire archive, and will
        * stop at the end of the current entry's data if the number
        * to skip extends beyond that point.
  -     * 
  +     *
        * @param numToSkip The number of bytes to skip.
        */
  -    public void skip(int numToSkip) throws IOException {
  -
  +    public long skip(long numToSkip) throws IOException {
           // REVIEW
           // This is horribly inefficient, but it ensures that we
           // properly skip over bytes via the TarBuffer...
  -        // 
  +        //
           byte[] skipBuf = new byte[8 * 1024];
  -
  -        for (int num = numToSkip; num > 0; ) {
  -            int numRead = this.read(skipBuf, 0, 
  -                                    (num > skipBuf.length ? skipBuf.length 
  -                                     : num));
  -
  +        long skip = numToSkip;
  +        while (skip > 0) {
  +            int realSkip = (int) (skip > skipBuf.length ? skipBuf.length : skip);
  +            int numRead = this.read(skipBuf, 0, realSkip);
               if (numRead == -1) {
                   break;
  -            } 
  -
  -            num -= numRead;
  -        } 
  -    } 
  +            }
  +            skip -= numRead;
  +        }
  +        return (numToSkip - skip);
  +    }
   
       /**
        * Since we do not support marking just yet, we return false.
  -     * 
  +     *
        * @return False.
        */
       public boolean markSupported() {
           return false;
  -    } 
  +    }
   
       /**
        * Since we do not support marking just yet, we do nothing.
  -     * 
  +     *
        * @param markLimit The limit to mark.
        */
  -    public void mark(int markLimit) {}
  +    public void mark(int markLimit) {
  +    }
   
       /**
        * Since we do not support marking just yet, we do nothing.
        */
  -    public void reset() {}
  +    public void reset() {
  +    }
   
       /**
        * Get the next entry in this tar archive. This will skip
  @@ -201,93 +200,93 @@
        * If there are no more entries in the archive, null will
        * be returned to indicate that the end of the archive has
        * been reached.
  -     * 
  +     *
        * @return The next TarEntry in the archive, or null.
        */
       public TarEntry getNextEntry() throws IOException {
           if (this.hasHitEOF) {
               return null;
  -        } 
  +        }
   
           if (this.currEntry != null) {
               int numToSkip = this.entrySize - this.entryOffset;
   
               if (this.debug) {
  -                System.err.println("TarInputStream: SKIP currENTRY '" 
  -                                   + this.currEntry.getName() + "' SZ " 
  -                                   + this.entrySize + " OFF " 
  -                                   + this.entryOffset + "  skipping " 
  -                                   + numToSkip + " bytes");
  -            } 
  +                System.err.println("TarInputStream: SKIP currENTRY '"
  +                        + this.currEntry.getName() + "' SZ "
  +                        + this.entrySize + " OFF "
  +                        + this.entryOffset + "  skipping "
  +                        + numToSkip + " bytes");
  +            }
   
               if (numToSkip > 0) {
                   this.skip(numToSkip);
  -            } 
  +            }
   
               this.readBuf = null;
  -        } 
  +        }
   
           byte[] headerBuf = this.buffer.readRecord();
   
           if (headerBuf == null) {
               if (this.debug) {
                   System.err.println("READ NULL RECORD");
  -            } 
  +            }
               this.hasHitEOF = true;
           } else if (this.buffer.isEOFRecord(headerBuf)) {
               if (this.debug) {
                   System.err.println("READ EOF RECORD");
  -            } 
  +            }
               this.hasHitEOF = true;
  -        } 
  +        }
   
           if (this.hasHitEOF) {
               this.currEntry = null;
           } else {
               this.currEntry = new TarEntry(headerBuf);
   
  -            if (!(headerBuf[257] == 'u' && headerBuf[258] == 's' 
  -                    && headerBuf[259] == 't' && headerBuf[260] == 'a' 
  +            if (!(headerBuf[257] == 'u' && headerBuf[258] == 's'
  +                    && headerBuf[259] == 't' && headerBuf[260] == 'a'
                       && headerBuf[261] == 'r')) {
                   this.entrySize = 0;
                   this.entryOffset = 0;
                   this.currEntry = null;
   
  -                throw new IOException("bad header in block " 
  -                                                 + this.buffer.getCurrentBlockNum() 
  -                                                 + " record " 
  -                                                 + this.buffer.getCurrentRecordNum() 
  -                                                 + ", " + 
  -                                       "header magic is not 'ustar', but '" 
  -                                                 + headerBuf[257] 
  -                                                 + headerBuf[258] 
  -                                                 + headerBuf[259] 
  -                                                 + headerBuf[260] 
  -                                                 + headerBuf[261] 
  -                                                 + "', or (dec) " 
  -                                                 + ((int) headerBuf[257]) 
  -                                                 + ", " 
  -                                                 + ((int) headerBuf[258]) 
  -                                                 + ", " 
  -                                                 + ((int) headerBuf[259]) 
  -                                                 + ", " 
  -                                                 + ((int) headerBuf[260]) 
  -                                                 + ", " 
  -                                                 + ((int) headerBuf[261]));
  -            } 
  +                throw new IOException("bad header in block "
  +                        + this.buffer.getCurrentBlockNum()
  +                        + " record "
  +                        + this.buffer.getCurrentRecordNum()
  +                        + ", " +
  +                        "header magic is not 'ustar', but '"
  +                        + headerBuf[257]
  +                        + headerBuf[258]
  +                        + headerBuf[259]
  +                        + headerBuf[260]
  +                        + headerBuf[261]
  +                        + "', or (dec) "
  +                        + ((int) headerBuf[257])
  +                        + ", "
  +                        + ((int) headerBuf[258])
  +                        + ", "
  +                        + ((int) headerBuf[259])
  +                        + ", "
  +                        + ((int) headerBuf[260])
  +                        + ", "
  +                        + ((int) headerBuf[261]));
  +            }
   
               if (this.debug) {
  -                System.err.println("TarInputStream: SET CURRENTRY '" 
  -                                   + this.currEntry.getName() 
  -                                   + "' size = " 
  -                                   + this.currEntry.getSize());
  -            } 
  +                System.err.println("TarInputStream: SET CURRENTRY '"
  +                        + this.currEntry.getName()
  +                        + "' size = "
  +                        + this.currEntry.getSize());
  +            }
   
               this.entryOffset = 0;
   
               // REVIEW How do we resolve this discrepancy?!
               this.entrySize = (int) this.currEntry.getSize();
  -        } 
  +        }
   
           if (this.currEntry != null && this.currEntry.isGNULongNameEntry()) {
               // read in the name
  @@ -302,13 +301,13 @@
           }
   
           return this.currEntry;
  -    } 
  +    }
   
       /**
        * Reads a byte from the current tar archive entry.
  -     * 
  +     *
        * This method simply calls read( byte[], int, int ).
  -     * 
  +     *
        * @return The byte read, or -1 at EOF.
        */
       public int read() throws IOException {
  @@ -319,27 +318,27 @@
           } else {
               return (int) this.oneBuf[0];
           }
  -    } 
  +    }
   
       /**
        * Reads bytes from the current tar archive entry.
  -     * 
  +     *
        * This method simply calls read( byte[], int, int ).
  -     * 
  +     *
        * @param buf The buffer into which to place bytes read.
        * @return The number of bytes read, or -1 at EOF.
        */
       public int read(byte[] buf) throws IOException {
           return this.read(buf, 0, buf.length);
  -    } 
  +    }
   
       /**
        * Reads bytes from the current tar archive entry.
  -     * 
  +     *
        * This method is aware of the boundaries of the current
        * entry in the archive and will deal with them as if they
        * were this stream's start and EOF.
  -     * 
  +     *
        * @param buf The buffer into which to place bytes read.
        * @param offset The offset at which to place bytes read.
        * @param numToRead The number of bytes to read.
  @@ -350,42 +349,42 @@
   
           if (this.entryOffset >= this.entrySize) {
               return -1;
  -        } 
  +        }
   
           if ((numToRead + this.entryOffset) > this.entrySize) {
               numToRead = (this.entrySize - this.entryOffset);
  -        } 
  +        }
   
           if (this.readBuf != null) {
  -            int sz = (numToRead > this.readBuf.length) ? this.readBuf.length 
  -                     : numToRead;
  +            int sz = (numToRead > this.readBuf.length) ? this.readBuf.length
  +                    : numToRead;
   
               System.arraycopy(this.readBuf, 0, buf, offset, sz);
   
               if (sz >= this.readBuf.length) {
                   this.readBuf = null;
               } else {
  -                int    newLen = this.readBuf.length - sz;
  +                int newLen = this.readBuf.length - sz;
                   byte[] newBuf = new byte[newLen];
   
                   System.arraycopy(this.readBuf, sz, newBuf, 0, newLen);
   
                   this.readBuf = newBuf;
  -            } 
  +            }
   
               totalRead += sz;
               numToRead -= sz;
               offset += sz;
  -        } 
  +        }
   
           while (numToRead > 0) {
               byte[] rec = this.buffer.readRecord();
   
               if (rec == null) {
                   // Unexpected EOF!
  -                throw new IOException("unexpected EOF with " + numToRead 
  -                                      + " bytes unread");
  -            } 
  +                throw new IOException("unexpected EOF with " + numToRead
  +                        + " bytes unread");
  +            }
   
               int sz = numToRead;
               int recLen = rec.length;
  @@ -400,22 +399,22 @@
                   sz = recLen;
   
                   System.arraycopy(rec, 0, buf, offset, recLen);
  -            } 
  +            }
   
               totalRead += sz;
               numToRead -= sz;
               offset += sz;
  -        } 
  +        }
   
           this.entryOffset += totalRead;
   
           return totalRead;
  -    } 
  +    }
   
       /**
        * Copies the contents of the current tar archive entry directly into
        * an output stream.
  -     * 
  +     *
        * @param out The OutputStream into which to write the entry's data.
        */
       public void copyEntryContents(OutputStream out) throws IOException {
  @@ -426,9 +425,9 @@
   
               if (numRead == -1) {
                   break;
  -            } 
  +            }
   
               out.write(buf, 0, numRead);
  -        } 
  -    } 
  +        }
  +    }
   }
  
  
  

--
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