xref: /external/smali/dexlib/src/main/java/org/jf/dexlib/Util/ByteArrayInput.java

/*
 * Copyright (C) 2007 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.jf.dexlib.Util;

/**
 * Implementation of {@link Input} which reads the data from a
 * <code>byte[]</code> instance.
 *
 * <p><b>Note:</b> As per the {@link Input } interface, multi-byte
 * reads all use little-endian order.</p>
 */
public class ByteArrayInput
    implements Input {

    /** non-null; the data itself */
    private byte[] data;

    /** &gt;= 0; current read cursor */
    private int cursor;

    /**
     * Constructs an instance with the given data
     *
     * @param data non-null; data array to use for input
     */
    public ByteArrayInput(byte[] data) {
        if (data == null) {
            throw new NullPointerException("data == null");
        }

        this.data = data;
        this.cursor = 0;
    }

    /**
     * Gets the underlying <code>byte[]</code> of this instance
     *
     * @return non-null; the <code>byte[]</code>
     */
    public byte[] getArray() {
        return data;
    }

    /** {@inheritDoc} */
    public int getCursor() {
        return cursor;
    }

    /** {@inheritDoc} */
    public void setCursor(int cursor) {
        if (cursor < 0 || cursor >= data.length)
            throw new IndexOutOfBoundsException("The provided cursor value " +
                    "is not within the bounds of this instance's data array");
        this.cursor = cursor;
    }

    /** {@inheritDoc} */
    public void assertCursor(int expectedCursor) {
        if (cursor != expectedCursor) {
            throw new ExceptionWithContext("expected cursor " +
                    expectedCursor + "; actual value: " + cursor);
        }
    }

    /** {@inheritDoc} */
    public byte readByte() {
        return data[cursor++];
    }

    /** {@inheritDoc} */
    public int readShort() {
        int readAt = cursor;
        int result = ((data[readAt++] & 0xff) +
                     ((data[readAt++] & 0xff) << 8));
        cursor = readAt;
        return result;
    }

    /** {@inheritDoc} */
    public int readInt() {
        int readAt = cursor;
        int result = (data[readAt++] & 0xff) +
                     ((data[readAt++] & 0xff) << 8) +
                     ((data[readAt++] & 0xff) << 16) +
                     ((data[readAt++] & 0xff) << 24);
        cursor = readAt;
        return result;
    }

    /** {@inheritDoc} */
    public long readLong() {
        int readAt = cursor;

        long result = (data[readAt++] & 0xffL) |
                      ((data[readAt++] & 0xffL) << 8) |
                      ((data[readAt++] & 0xffL) << 16) |
                      ((data[readAt++] & 0xffL) << 24) |
                      ((data[readAt++] & 0xffL) << 32) |
                      ((data[readAt++] & 0xffL) << 40) |
                      ((data[readAt++] & 0xffL) << 48) |
                      ((data[readAt++] & 0xffL) << 58);
        cursor = readAt;
        return result;
    }


    /** {@inheritDoc} */
    public int readUnsignedOrSignedLeb128() {
        int end = cursor;
        int currentByteValue;
        int result;

        result = data[end++] & 0xff;
        if (result > 0x7f) {
            currentByteValue = data[end++] & 0xff;
            result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
            if (currentByteValue > 0x7f) {
                currentByteValue = data[end++] & 0xff;
                result |= (currentByteValue & 0x7f) << 14;
                if (currentByteValue > 0x7f) {
                    currentByteValue = data[end++] & 0xff;
                    result |= (currentByteValue & 0x7f) << 21;
                    if (currentByteValue > 0x7f) {
                        currentByteValue = data[end++] & 0xff;
                        if (currentByteValue > 0x0f) {
                            throwInvalidLeb();
                        }
                        result |= currentByteValue << 28;
                    }
                }
            }
        } else {
            cursor = end;
            return result;
        }

        cursor = end;

        //If the last byte is 0, then this was an unsigned value (incorrectly) written in a signed format
        //The caller wants to know if this is the case, so we'll return the negated value instead
        //If there was only a single byte that had a value of 0, then we would have returned in the above
        //"else"
        if (data[end-1] == 0) {
            return ~result;
        }
        return result;
    }




    /** {@inheritDoc} */
    public int readUnsignedLeb128() {
        int end = cursor;
        int currentByteValue;
        int result;

        result = data[end++] & 0xff;
        if (result > 0x7f) {
            currentByteValue = data[end++] & 0xff;
            result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
            if (currentByteValue > 0x7f) {
                currentByteValue = data[end++] & 0xff;
                result |= (currentByteValue & 0x7f) << 14;
                if (currentByteValue > 0x7f) {
                    currentByteValue = data[end++] & 0xff;
                    result |= (currentByteValue & 0x7f) << 21;
                    if (currentByteValue > 0x7f) {
                        currentByteValue = data[end++] & 0xff;
                        if (currentByteValue > 0x0f) {
                            throwInvalidLeb();
                        }
                        result |= currentByteValue << 28;
                    }
                }
            }
        }

        cursor = end;
        return result;
    }

    /** {@inheritDoc} */
    public int readSignedLeb128() {
        int end = cursor;
        int currentByteValue;
        int result;

        result = data[end++] & 0xff;
        if (result <= 0x7f) {
            result = (result << 25) >> 25;
        } else {
            currentByteValue = data[end++] & 0xff;
            result = (result & 0x7f) | ((currentByteValue & 0x7f) << 7);
            if (currentByteValue <= 0x7f) {
                result = (result << 18) >> 18;
            } else {
                currentByteValue = data[end++] & 0xff;
                result |= (currentByteValue & 0x7f) << 14;
                if (currentByteValue <= 0x7f) {
                    result = (result << 11) >> 11;
                } else {
                    currentByteValue = data[end++] & 0xff;
                    result |= (currentByteValue & 0x7f) << 21;
                    if (currentByteValue <= 0x7f) {
                        result = (result << 4) >> 4;
                    } else {
                        currentByteValue = data[end++] & 0xff;
                        if (currentByteValue > 0x0f) {
                            throwInvalidLeb();
                        }
                        result |= currentByteValue << 28;
                    }
                }
            }
        }

        cursor = end;
        return result;
    }

    /** {@inheritDoc} */
    public void read(byte[] bytes, int offset, int length) {
        int end = cursor + length;

        if (end > data.length) {
            throwBounds();
        }

        System.arraycopy(data, cursor, bytes, offset, length);
        cursor = end;
    }

    /** {@inheritDoc} */
    public void read(byte[] bytes) {
        int length = bytes.length;
        int end = cursor + length;

        if (end > data.length) {
            throwBounds();
        }

        System.arraycopy(data, cursor, bytes, 0, length);
        cursor = end;
    }

    /** {@inheritDoc} */
    public byte[] readBytes(int length) {
        int end = cursor + length;

        if (end > data.length) {
            throwBounds();
        }

        byte[] result = new byte[length];
        System.arraycopy(data, cursor, result, 0, length);
        cursor = end;
        return result;
    }

    /** {@inheritDoc} */
    public String realNullTerminatedUtf8String() {
        int startPosition = cursor;
        while (data[cursor] != 0) {
            cursor++;
        }
        int byteCount = cursor - startPosition;

        //skip the terminating null
        cursor++;

        return Utf8Utils.utf8BytesToString(data, startPosition, byteCount);
    }

    /** {@inheritDoc} */
    public void skipBytes(int count) {
        cursor += count;
    }

    /** {@inheritDoc} */
    public void alignTo(int alignment) {
        cursor = AlignmentUtils.alignOffset(cursor, alignment);
    }

    /**
     * Throws the excpetion for when an attempt is made to read past the
     * end of the instance.
     */
    private static void throwBounds() {
        throw new IndexOutOfBoundsException("attempt to read past the end");
    }

    /**
     * Throws the exception for when an invalid LEB128 value is encountered
     */
    private static void throwInvalidLeb() {
        throw new RuntimeException("invalid LEB128 integer encountered");
    }
}