This is an automated email from the git hooks/post-receive script. apo-guest pushed a commit to branch master in repository apktool.
commit 818b20cb03aea8ba19b5baac2d1525f0944ed548 Author: Markus Koschany <[email protected]> Date: Tue Feb 16 17:51:57 2016 +0100 test --- debian/patches/LEDataInputStream.java.patch | 2 +- debian/patches/series | 1 + debian/patches/test.patch | 530 ++++++++++++++++++++++++++++ 3 files changed, 532 insertions(+), 1 deletion(-) diff --git a/debian/patches/LEDataInputStream.java.patch b/debian/patches/LEDataInputStream.java.patch index 2dd33a5..b0c0a1a 100644 --- a/debian/patches/LEDataInputStream.java.patch +++ b/debian/patches/LEDataInputStream.java.patch @@ -9,7 +9,7 @@ Subject: LEDataInputStream.java diff --git a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java new file mode 100644 -index 0000000..293cb1d +index 0000000..9418e64 --- /dev/null +++ b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java @@ -0,0 +1,186 @@ diff --git a/debian/patches/series b/debian/patches/series index 90d6b09..d74f901 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1,3 +1,4 @@ use_system_aapt.patch build.patch LEDataInputStream.java.patch +test.patch diff --git a/debian/patches/test.patch b/debian/patches/test.patch new file mode 100644 index 0000000..860d1bb --- /dev/null +++ b/debian/patches/test.patch @@ -0,0 +1,530 @@ +From: Markus Koschany <[email protected]> +Date: Tue, 16 Feb 2016 17:51:48 +0100 +Subject: test + +--- + .../mindprod/ledatastream/LEDataInputStream.java | 516 +++++++++++++-------- + 1 file changed, 330 insertions(+), 186 deletions(-) + +diff --git a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java +index 9418e64..b650e4b 100644 +--- a/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java ++++ b/brut.apktool/apktool-lib/src/main/java/com/mindprod/ledatastream/LEDataInputStream.java +@@ -1,186 +1,330 @@ +-/******************************************************************************* +- * Copyright (c) 2000, 2011 IBM Corporation and others. +- * All rights reserved. This program and the accompanying materials +- * are made available under the terms of the Eclipse Public License v1.0 +- * which accompanies this distribution, and is available at +- * http://www.eclipse.org/legal/epl-v10.html +- * +- * Contributors: +- * IBM Corporation - initial API and implementation +- *******************************************************************************/ +-package com.mindprod.ledatastream; +- +- +-import java.io.*; +- +-public final class LEDataInputStream extends InputStream { +- int position; +- InputStream in; +- +- /** +- * The byte array containing the bytes to read. +- */ +- protected byte[] buf; +- +- /** +- * The current position within the byte array <code>buf</code>. A value +- * equal to buf.length indicates no bytes available. A value of +- * 0 indicates the buffer is full. +- */ +- protected int pos; +- +- +- public LEDataInputStream(InputStream input) { +- this(input, 512); +- } +- +- public LEDataInputStream(InputStream input, int bufferSize) { +- this.in = input; +- if (bufferSize > 0) { +- buf = new byte[bufferSize]; +- pos = bufferSize; +- } +- else throw new IllegalArgumentException(); +- } +- +- public void close() throws IOException { +- buf = null; +- if (in != null) { +- in.close(); +- in = null; +- } +- } +- +- /** +- * Answer how many bytes were read. +- */ +- public int getPosition() { +- return position; +- } +- +- /** +- * Answers how many bytes are available for reading without blocking +- */ +- public int available() throws IOException { +- if (buf == null) throw new IOException(); +- return (buf.length - pos) + in.available(); +- } +- +- /** +- * Answer the next byte of the input stream. +- */ +- public int read() throws IOException { +- if (buf == null) throw new IOException(); +- if (pos < buf.length) { +- position++; +- return (buf[pos++] & 0xFF); +- } +- int c = in.read(); +- if (c != -1) position++; +- return c; +- } +- +- /** +- * Don't imitate the JDK behaviour of reading a random number +- * of bytes when you can actually read them all. +- */ +- public int read(byte b[], int off, int len) throws IOException { +- int read = 0, count; +- while (read != len && (count = readData(b, off, len - read)) != -1) { +- off += count; +- read += count; +- } +- position += read; +- if (read == 0 && read != len) return -1; +- return read; +- } +- +- /** +- * Reads at most <code>length</code> bytes from this LEDataInputStream and +- * stores them in byte array <code>buffer</code> starting at <code>offset</code>. +- * <p> +- * Answer the number of bytes actually read or -1 if no bytes were read and +- * end of stream was encountered. This implementation reads bytes from +- * the pushback buffer first, then the target stream if more bytes are required +- * to satisfy <code>count</code>. +- * </p> +- * @param buffer the byte array in which to store the read bytes. +- * @param offset the offset in <code>buffer</code> to store the read bytes. +- * @param length the maximum number of bytes to store in <code>buffer</code>. +- * +- * @return int the number of bytes actually read or -1 if end of stream. +- * +- * @exception java.io.IOException if an IOException occurs. +- */ +- private int readData(byte[] buffer, int offset, int length) throws IOException { +- if (buf == null) throw new IOException(); +- if (offset < 0 || offset > buffer.length || +- length < 0 || (length > buffer.length - offset)) { +- throw new ArrayIndexOutOfBoundsException(); +- } +- +- int cacheCopied = 0; +- int newOffset = offset; +- +- // Are there pushback bytes available? +- int available = buf.length - pos; +- if (available > 0) { +- cacheCopied = (available >= length) ? length : available; +- System.arraycopy(buf, pos, buffer, newOffset, cacheCopied); +- newOffset += cacheCopied; +- pos += cacheCopied; +- } +- +- // Have we copied enough? +- if (cacheCopied == length) return length; +- +- int inCopied = in.read(buffer, newOffset, length - cacheCopied); +- +- if (inCopied > 0) return inCopied + cacheCopied; +- if (cacheCopied == 0) return inCopied; +- return cacheCopied; +- } +- +- /** +- * Answer an integer comprised of the next +- * four bytes of the input stream. +- */ +- public int readInt() throws IOException { +- byte[] buf = new byte[4]; +- read(buf); +- return ((buf[3] & 0xFF) << 24) | +- ((buf[2] & 0xFF) << 16) | +- ((buf[1] & 0xFF) << 8) | +- (buf[0] & 0xFF); +- } +- +- /** +- * Answer a short comprised of the next +- * two bytes of the input stream. +- */ +- public short readShort() throws IOException { +- byte[] buf = new byte[2]; +- read(buf); +- return (short)(((buf[1] & 0xFF) << 8) | (buf[0] & 0xFF)); +- } +- +- /** +- * Push back the entire content of the given buffer <code>b</code>. +- * <p> +- * The bytes are pushed so that they would be read back b[0], b[1], etc. +- * If the push back buffer cannot handle the bytes copied from <code>b</code>, +- * an IOException will be thrown and no byte will be pushed back. +- * </p> +- * +- * @param b the byte array containing bytes to push back into the stream +- * +- * @exception java.io.IOException if the pushback buffer is too small +- */ +- public void unread(byte[] b) throws IOException { +- int length = b.length; +- if (length > pos) throw new IOException(); +- position -= length; +- pos -= length; +- System.arraycopy(b, 0, buf, pos, length); +- } +-} ++/* ++ * @(#)LEDataInputStream.java ++ * ++ * Summary: Little-Endian version of DataInputStream. ++ * ++ * Copyright: (c) 1998-2010 Roedy Green, Canadian Mind Products, http://mindprod.com ++ * ++ * Licence: This software may be copied and used freely for any purpose but military. ++ * http://mindprod.com/contact/nonmil.html ++ * ++ * Requires: JDK 1.1+ ++ * ++ * Created with: IntelliJ IDEA IDE. ++ * ++ * Version History: ++ * 1.8 2007-05-24 ++ */ ++package com.mindprod.ledatastream; ++ ++import java.io.DataInput; ++import java.io.DataInputStream; ++import java.io.IOException; ++import java.io.InputStream; ++ ++/** ++ * Little-Endian version of DataInputStream. ++ * <p/> ++ * Very similar to DataInputStream except it reads little-endian instead of ++ * big-endian binary data. We can't extend DataInputStream directly since it has ++ * only final methods, though DataInputStream itself is not final. This forces ++ * us implement LEDataInputStream with a DataInputStream object, and use wrapper ++ * methods. ++ * ++ * @author Roedy Green, Canadian Mind Products ++ * @version 1.8 2007-05-24 ++ * @since 1998 ++ */ ++public final class LEDataInputStream implements DataInput { ++ // ------------------------------ CONSTANTS ------------------------------ ++ ++ /** ++ * undisplayed copyright notice. ++ * ++ * @noinspection UnusedDeclaration ++ */ ++ private static final String EMBEDDED_COPYRIGHT = "copyright (c) 1999-2010 Roedy Green, Canadian Mind Products, http://mindprod.com";; ++ ++ // ------------------------------ FIELDS ------------------------------ ++ ++ /** ++ * to get at the big-Endian methods of a basic DataInputStream ++ * ++ * @noinspection WeakerAccess ++ */ ++ protected final DataInputStream dis; ++ ++ /** ++ * to get at the a basic readBytes method. ++ * ++ * @noinspection WeakerAccess ++ */ ++ protected final InputStream is; ++ ++ /** ++ * work array for buffering input. ++ * ++ * @noinspection WeakerAccess ++ */ ++ protected final byte[] work; ++ ++ // -------------------------- PUBLIC STATIC METHODS ++ // -------------------------- ++ ++ /** ++ * Note. This is a STATIC method! ++ * ++ * @param in ++ * stream to read UTF chars from (endian irrelevant) ++ * ++ * @return string from stream ++ * @throws IOException ++ * if read fails. ++ */ ++ public static String readUTF(DataInput in) throws IOException { ++ return DataInputStream.readUTF(in); ++ } ++ ++ // -------------------------- PUBLIC INSTANCE METHODS ++ // -------------------------- ++ ++ /** ++ * constructor. ++ * ++ * @param in ++ * binary inputstream of little-endian data. ++ */ ++ public LEDataInputStream(InputStream in) { ++ this.is = in; ++ this.dis = new DataInputStream(in); ++ work = new byte[8]; ++ } ++ ++ /** ++ * close. ++ * ++ * @throws IOException ++ * if close fails. ++ */ ++ public final void close() throws IOException { ++ dis.close(); ++ } ++ ++ /** ++ * Read bytes. Watch out, read may return fewer bytes than requested. ++ * ++ * @param ba ++ * where the bytes go. ++ * @param off ++ * offset in buffer, not offset in file. ++ * @param len ++ * count of bytes to read. ++ * ++ * @return how many bytes read. ++ * @throws IOException ++ * if read fails. ++ */ ++ public final int read(byte ba[], int off, int len) throws IOException { ++ // For efficiency, we avoid one layer of wrapper ++ return is.read(ba, off, len); ++ } ++ ++ /** ++ * read only a one-byte boolean. ++ * ++ * @return true or false. ++ * @throws IOException ++ * if read fails. ++ * @see java.io.DataInput#readBoolean() ++ */ ++ @Override ++ public final boolean readBoolean() throws IOException { ++ return dis.readBoolean(); ++ } ++ ++ /** ++ * read byte. ++ * ++ * @return the byte read. ++ * @throws IOException ++ * if read fails. ++ * @see java.io.DataInput#readByte() ++ */ ++ @Override ++ public final byte readByte() throws IOException { ++ return dis.readByte(); ++ } ++ ++ /** ++ * Read on char. like DataInputStream.readChar except little endian. ++ * ++ * @return little endian 16-bit unicode char from the stream. ++ * @throws IOException ++ * if read fails. ++ */ ++ @Override ++ public final char readChar() throws IOException { ++ dis.readFully(work, 0, 2); ++ return (char) ((work[1] & 0xff) << 8 | (work[0] & 0xff)); ++ } ++ ++ /** ++ * Read a double. like DataInputStream.readDouble except little endian. ++ * ++ * @return little endian IEEE double from the datastream. ++ * @throws IOException ++ */ ++ @Override ++ public final double readDouble() throws IOException { ++ return Double.longBitsToDouble(readLong()); ++ } ++ ++ /** ++ * Read one float. Like DataInputStream.readFloat except little endian. ++ * ++ * @return little endian IEEE float from the datastream. ++ * @throws IOException ++ * if read fails. ++ */ ++ @Override ++ public final float readFloat() throws IOException { ++ return Float.intBitsToFloat(readInt()); ++ } ++ ++ /** ++ * Read bytes until the array is filled. ++ * ++ * @see java.io.DataInput#readFully(byte[]) ++ */ ++ @Override ++ public final void readFully(byte ba[]) throws IOException { ++ dis.readFully(ba, 0, ba.length); ++ } ++ ++ /** ++ * Read bytes until the count is satisfied. ++ * ++ * @throws IOException ++ * if read fails. ++ * @see java.io.DataInput#readFully(byte[],int,int) ++ */ ++ @Override ++ public final void readFully(byte ba[], int off, int len) throws IOException { ++ dis.readFully(ba, off, len); ++ } ++ ++ /** ++ * Read an int, 32-bits. Like DataInputStream.readInt except little endian. ++ * ++ * @return little-endian binary int from the datastream ++ * @throws IOException ++ * if read fails. ++ */ ++ @Override ++ public final int readInt() throws IOException { ++ dis.readFully(work, 0, 4); ++ return (work[3]) << 24 | (work[2] & 0xff) << 16 | (work[1] & 0xff) << 8 ++ | (work[0] & 0xff); ++ } ++ ++ /** ++ * Read a line. ++ * ++ * @return a rough approximation of the 8-bit stream as a 16-bit unicode ++ * string ++ * @throws IOException ++ * @noinspection deprecation ++ * @deprecated This method does not properly convert bytes to characters. ++ * Use a Reader instead with a little-endian encoding. ++ */ ++ @Deprecated ++ @Override ++ public final String readLine() throws IOException { ++ return dis.readLine(); ++ } ++ ++ /** ++ * read a long, 64-bits. Like DataInputStream.readLong except little endian. ++ * ++ * @return little-endian binary long from the datastream. ++ * @throws IOException ++ */ ++ @Override ++ public final long readLong() throws IOException { ++ dis.readFully(work, 0, 8); ++ return (long) (work[7]) << 56 | ++ /* long cast needed or shift done modulo 32 */ ++ (long) (work[6] & 0xff) << 48 | (long) (work[5] & 0xff) << 40 ++ | (long) (work[4] & 0xff) << 32 | (long) (work[3] & 0xff) << 24 ++ | (long) (work[2] & 0xff) << 16 | (long) (work[1] & 0xff) << 8 ++ | work[0] & 0xff; ++ } ++ ++ /** ++ * Read short, 16-bits. Like DataInputStream.readShort except little endian. ++ * ++ * @return little endian binary short from stream. ++ * @throws IOException ++ * if read fails. ++ */ ++ @Override ++ public final short readShort() throws IOException { ++ dis.readFully(work, 0, 2); ++ return (short) ((work[1] & 0xff) << 8 | (work[0] & 0xff)); ++ } ++ ++ /** ++ * Read UTF counted string. ++ * ++ * @return String read. ++ */ ++ @Override ++ public final String readUTF() throws IOException { ++ return dis.readUTF(); ++ } ++ ++ /** ++ * Read an unsigned byte. Note: returns an int, even though says Byte ++ * (non-Javadoc) ++ * ++ * @throws IOException ++ * if read fails. ++ * @see java.io.DataInput#readUnsignedByte() ++ */ ++ @Override ++ public final int readUnsignedByte() throws IOException { ++ return dis.readUnsignedByte(); ++ } ++ ++ /** ++ * Read an unsigned short, 16 bits. Like DataInputStream.readUnsignedShort ++ * except little endian. Note, returns int even though it reads a short. ++ * ++ * @return little-endian int from the stream. ++ * @throws IOException ++ * if read fails. ++ */ ++ @Override ++ public final int readUnsignedShort() throws IOException { ++ dis.readFully(work, 0, 2); ++ return ((work[1] & 0xff) << 8 | (work[0] & 0xff)); ++ } ++ ++ /** ++ * Skip over bytes in the stream. See the general contract of the ++ * <code>skipBytes</code> method of <code>DataInput</code>. ++ * <p/> ++ * Bytes for this operation are read from the contained input stream. ++ * ++ * @param n ++ * the number of bytes to be skipped. ++ * ++ * @return the actual number of bytes skipped. ++ * @throws IOException ++ * if an I/O error occurs. ++ */ ++ @Override ++ public final int skipBytes(int n) throws IOException { ++ return dis.skipBytes(n); ++ } ++} +\ No newline at end of file -- Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-java/apktool.git _______________________________________________ pkg-java-commits mailing list [email protected] http://lists.alioth.debian.org/cgi-bin/mailman/listinfo/pkg-java-commits
