/*
* Copyright 2006 ProductiveMe Inc.
* Copyright 2013 JetBrains s.r.o.
*
* 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 com.pme.exe;
import com.pme.util.BitsUtil;
import com.pme.util.OffsetTrackingInputStream;
import java.io.*;
import java.util.ArrayList;
import java.util.HashMap;
import java.lang.reflect.Array;
/**
* Date: Mar 31, 2006
* Time: 6:17:24 PM
*/
public abstract class Bin {
private String myName;
private String myDescription;
private long myOffset = 0;
ArrayList<Bin.Value> myOffsetHolders = new ArrayList<Bin.Value>(0);
ArrayList<Bin.Value> mySizeHolders = new ArrayList<Bin.Value>(0);
public Bin(String name) {
myName = name;
}
public String getName() {
return myName;
}
public void setName(String name) {
myName = name;
}
public String getDescription() {
if (myDescription != null) {
return myDescription;
}
return myName;
}
public long getOffset() {
return myOffset;
}
public void resetOffsets(long offset) {
myOffset = offset;
updateSizeOffsetHolders();
}
protected void updateSizeOffsetHolders() {
for (Value holder : myOffsetHolders) {
holder.setValue(myOffset);
}
for (Value holder : mySizeHolders) {
holder.setValue(sizeInBytes());
}
}
public void copyFrom(Bin value) {
}
public void addOffsetHolder(Value offsetHolder) {
myOffsetHolders.add( offsetHolder );
}
public void addSizeHolder(Value sizeHolder) {
mySizeHolders.add( sizeHolder );
}
public abstract long sizeInBytes();
public void setDescription(String description) {
myDescription = description;
}
public abstract void read(DataInput stream) throws IOException;
public abstract void write(DataOutput stream) throws IOException;
public abstract void report(OutputStreamWriter writer) throws IOException;
public static class Comment extends Bin {
public Comment(String comment) {
super(comment);
}
public long sizeInBytes() {
return 0;
}
public void read(DataInput stream) throws IOException {
}
public void write(DataOutput stream) throws IOException {
}
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, getName());
}
}
public static class Structure extends Bin {
private ArrayList<Bin> myMembers = new ArrayList<Bin>(1);
private HashMap<String, Bin> myMembersMap = new HashMap<String, Bin>(1);
public Structure(String name) {
super(name);
}
public void resetOffsets(long newOffset) {
super.resetOffsets(newOffset);
long offset = getOffset();
for (Bin bin : myMembers) {
bin.resetOffsets(offset);
offset = offset + bin.sizeInBytes();
}
updateSizeOffsetHolders();
}
public void copyFrom(Bin binStructure) {
Bin.Structure structure = (Bin.Structure)binStructure;
ArrayList<Bin> members = structure.getMembers();
for (Bin bin : members) {
Bin valueMember = getMember(bin.getName());
if (valueMember != null) {
valueMember.copyFrom(bin);
}
}
}
public long sizeInBytes() {
long size = 0;
for (Bin bin : myMembers) {
size += bin.sizeInBytes();
}
return size;
}
public ArrayList<Bin> getMembers() {
return myMembers;
}
public void addMember(Bin bin, String description) {
bin.setDescription(description);
addMember(bin);
}
public void addComment(String message) {
myMembers.add(new Comment(message));
}
public Bin insertMember(int index, Bin bin) {
ArrayList<Bin> list = new ArrayList<Bin>( myMembers.size() + 1 );
for ( int i = 0; i < index; ++i ){
list.add( myMembers.get( i ) );
}
list.add( bin );
for ( int i = index; i < myMembers.size(); ++i ){
list.add( myMembers.get( i ) );
}
myMembers = list;
addMemberToMapOnly(bin);
return bin;
}
public Bin addMember(Bin bin) {
myMembers.add(bin);
addMemberToMapOnly(bin);
return bin;
}
//such members are not read by framework
//it is read by parent in 'read' overrided method
public void addMemberToMapOnly(Bin bin) {
myMembersMap.put(bin.getName(), bin);
}
public Bin getMember(String name) {
return myMembersMap.get(name);
}
public Bin.Value getValueMember(String name) {
return (Bin.Value) myMembersMap.get(name);
}
public Bin.Structure getStructureMember(String name) {
return (Bin.Structure) myMembersMap.get(name);
}
public long getValue(String name) {
return ((Bin.Value) myMembersMap.get(name)).getValue();
}
public void read(DataInput stream) throws IOException {
for (Bin bin : myMembers) {
bin.read(stream);
}
}
public void write(DataOutput stream) throws IOException {
for (Bin bin : myMembers) {
bin.write(stream);
}
}
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, "--- '" + getName() + "' Structure --- size = " + sizeInBytes());
_report(writer, "{Offset = " + Long.toHexString(getOffset()) + "}");
for (Bin bin : myMembers) {
bin.report(writer);
}
_report(writer, "--- End Of '" + getName() + "' Structure ---");
}
}
public abstract static class Value extends Bin {
private long myValue;
public Value(String name) {
super(name);
}
public abstract long getValue();
public abstract Value setValue(long value);
public void copyFrom(Bin value) {
setValue(((Value)value).getValue());
}
public long getRawValue() {
return myValue;
}
public Value setRawValue(long value) {
myValue = value;
return this;
}
}
public static class Byte extends Value {
public Byte(String name) {
super(name);
}
public long sizeInBytes() {
return 1;
}
public long getValue() {
return getRawValue();
}
public Value setValue(long value) {
setRawValue(value);
return this;
}
public void read(DataInput stream) throws IOException {
setRawValue(stream.readByte());
}
public void write(DataOutput stream) throws IOException {
stream.writeByte((byte) getRawValue());
}
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, getDescription(), (byte) getValue());
}
}
public static class Word extends Value {
public Word() {
super("");
}
public Word(String name) {
super(name);
}
public long sizeInBytes() {
return 2;
}
public long getValue() {
return BitsUtil.revertBytesOfShort((short) super.getRawValue());
}
public Value setValue(long value) {
setRawValue(BitsUtil.revertBytesOfShort((short) value));
return this;
}
public void read(DataInput stream) throws IOException {
setRawValue(stream.readShort());
}
public void write(DataOutput stream) throws IOException {
stream.writeShort((short) getRawValue());
}
public void report(OutputStreamWriter writer) throws IOException {
short sh = (short) getValue();
_report(writer, getDescription(), sh);
}
public String toString() {
return BitsUtil.shortToHexString( (int)getValue() );
}
}
public static class DWord extends Value {
public DWord(String name) {
super(name);
}
public long sizeInBytes() {
return 4;
}
public Value setValue(long value) {
setRawValue(BitsUtil.revertBytesOfInt((int) value));
return this;
}
public long getValue() {
return BitsUtil.revertBytesOfInt((int) super.getRawValue());
}
public void read(DataInput stream) throws IOException {
setRawValue(stream.readInt());
}
public void write(DataOutput stream) throws IOException {
stream.writeInt((int) getRawValue());
}
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, getDescription(), (int) getValue());
}
public String toString() {
return BitsUtil.intToHexString( (int)getValue() );
}
}
public static class LongLong extends Value {
public LongLong(String name) {
super(name);
}
@Override
public long getValue() {
return BitsUtil.revertBytesOfLong(getRawValue());
}
@Override
public Value setValue(long value) {
setRawValue(BitsUtil.revertBytesOfLong(value));
return this;
}
@Override
public long sizeInBytes() {
return 8;
}
@Override
public void read(DataInput stream) throws IOException {
setRawValue(stream.readLong());
}
@Override
public void write(DataOutput stream) throws IOException {
stream.writeLong(getRawValue());
}
@Override
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, getDescription() + " : " + Long.toHexString(getValue()));
}
}
public static class Padding extends Bin {
private int myBytes;
public Padding(int bytes) {
super("Padding");
myBytes = bytes;
}
@Override
public long sizeInBytes() {
return bytesToSkip(getOffset());
}
@Override
public void read(DataInput stream) throws IOException {
if (stream instanceof OffsetTrackingInputStream) {
long offset = ((OffsetTrackingInputStream) stream).getOffset();
int skip = bytesToSkip(offset);
if (skip > 0) {
stream.skipBytes(skip);
}
}
}
private int bytesToSkip(long offset) {
int offsetMask = myBytes-1;
long offsetBits = offset & offsetMask;
return offsetBits == 0 ? 0 : (int) (myBytes - offsetBits);
}
@Override
public void write(DataOutput stream) throws IOException {
int skip = bytesToSkip(getOffset());
for (int i = 0; i < skip; i++) {
stream.writeByte(0);
}
}
@Override
public void report(OutputStreamWriter writer) throws IOException {
}
}
public static class Txt extends Bin {
private StringBuffer myBuffer = new StringBuffer();
private Bin.Value mySize;
private byte[] myBytes;
public Txt(String name, byte[] bytes) {
super(name);
myBytes = bytes;
mySize = new DWord("").setValue(bytes.length);
setValue();
}
public Txt(String name, String string) {
super(name);
myBytes = new byte[string.length() * 2];
byte[] bytes = string.getBytes();
for (int i = 0; i < bytes.length; ++i) {
myBytes[i * 2] = bytes[i];
myBytes[i * 2 + 1] = 0;
}
mySize = new DWord("").setValue(myBytes.length);
setValue();
}
public Txt(String name, Bin.Value size) {
super(name);
mySize = size;
}
public Txt(String name, int size) {
this(name, new DWord("size").setValue(size));
}
public String getText() {
return myBuffer.toString();
}
public long sizeInBytes() {
return mySize.getValue();
}
private void setValue(){
for (int i = 0; i < mySize.getValue(); ++i) {
int b = BitsUtil.unsignedByte(myBytes[i]);
if (b != 0) {
myBuffer.append((char) b);
}
}
}
public void read(DataInput stream) throws IOException {
myBuffer.setLength(0);
myBytes = new byte[(int) mySize.getValue()];
for (int i = 0; i < mySize.getValue(); ++i) {
myBytes[i] = stream.readByte();
}
setValue();
}
public void write(DataOutput stream) throws IOException {
stream.write(myBytes);
}
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, myBuffer.toString());
}
}
public static class WChar extends Bin {
private String myValue;
public WChar(String name) {
super(name);
}
@Override
public long sizeInBytes() {
return myValue.length() * 2 + 2;
}
@Override
public void read(DataInput stream) throws IOException {
StringBuilder valueBuilder = new StringBuilder();
while(true) {
char c = BitsUtil.readChar(stream);
if (c == 0) break;
valueBuilder.append(c);
}
myValue = valueBuilder.toString();
}
@Override
public void write(DataOutput stream) throws IOException {
for (int i = 0; i < myValue.length(); i++) {
stream.writeShort(BitsUtil.revertBytesOfShort((short) myValue.charAt(i)));
}
stream.writeShort(0);
}
@Override
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, myValue);
}
public String getValue() {
return myValue;
}
public void setValue(String value) {
myValue = value;
}
}
public static class Bytes extends Bin {
private byte[] myBytes;
private Value myStartOffset;
private Value mySize;
private int myBytesInRow = 16;
public Bytes(String name, Bin.Value size) {
super(name);
mySize = size;
}
public Bytes(String name, long size) {
super(name);
mySize = new DWord("size").setValue(size);
}
public Bytes(String name, Bin.Value startOffset, Bin.Value size) {
super(name);
reset(startOffset, size);
}
public void reset(int startOffset, int size) {
reset(new DWord("startOffset").setValue(startOffset), new DWord("size").setValue(size));
}
public void reset(Bin.Value startOffset, Bin.Value size) {
myStartOffset = startOffset;
mySize = size;
}
public byte[] getBytes() {
return myBytes;
}
public void setBytes(byte[] bytes) {
setBytes(bytes, bytes.length);
}
public void setBytes(byte[] bytes, int size) {
if (bytes.length < size) {
throw new RuntimeException("bytes.length < size");
}
myBytes = bytes;
mySize.setValue(size);
}
public long sizeInBytes() {
return mySize.getValue();
}
public void read(DataInput stream) throws IOException {
if (myStartOffset != null) {
RandomAccessFile file = (RandomAccessFile) stream;
file.seek(myStartOffset.getValue());
}
myBytes = new byte[(int) mySize.getValue()];
stream.readFully(myBytes);
}
public void write(DataOutput stream) throws IOException {
stream.write(myBytes, 0, (int) sizeInBytes());
}
private StringBuffer myBuffer = new StringBuffer();
public void report(OutputStreamWriter writer) throws IOException {
_report(writer, getName());
_report(writer, "Number of bytes: " + mySize.getValue());
int rowCount = (myBytes.length / myBytesInRow);
if (myBytes.length % myBytesInRow != 0) {
rowCount++;
}
int byteCount = 0;
for (int i = 0; i < rowCount; i++) {
myBuffer.setLength(0);
myBuffer.append("\n");
for (int j = 0; j < myBytesInRow && byteCount < myBytes.length; j++) {
byte aByte = myBytes[byteCount++];
myBuffer.append(" ").append(BitsUtil.byteToHexString(aByte));
}
writer.write(myBuffer.toString());
}
}
}
public static class ArrayOfBins<T extends Bin> extends Bin {
private Bin[] myValues;
private Bin.Value mySize;
private Class myClass;
private Bin.Value myCountHolder = null;
public ArrayOfBins(String name, Class<T> cl, Bin.Value size) {
super(name);
myClass = cl;
mySize = size;
init();
}
public ArrayOfBins(String name, Class<T> cl, int size) {
this(name, cl, new DWord("size").setValue(size));
}
public void addBin( Bin bin ){
Bin[] newArray = new Bin[myValues.length+1];
System.arraycopy( myValues, 0, newArray, 0, myValues.length );
newArray[myValues.length] = bin;
myValues = newArray;
mySize.setValue( mySize.getValue() + 1 );
}
public void copyFrom(Bin bin) {
ArrayOfBins value = (ArrayOfBins)bin;
for (int i = 0; i < myValues.length; i++) {
myValues[i].copyFrom( value.get(i) );
}
}
public void setCountHolder(Value countHolder) {
myCountHolder = countHolder;
}
private void init() {
myValues = (Bin[]) Array.newInstance(myClass, (int) mySize.getValue());
for (int i = 0; i < myValues.length; i++) {
try {
Bin bin = (Bin) myClass.newInstance();
bin.setName("[" + i + "]");
myValues[i] = bin;
} catch (InstantiationException e) {
throw new RuntimeException(e.getMessage());
} catch (IllegalAccessException e) {
throw new RuntimeException(e.getMessage());
}
}
}
public void resetOffsets(long newOffset) {
super.resetOffsets(newOffset);
long offset = getOffset();
if (myCountHolder != null) {
myCountHolder.setValue(myValues.length);
}
for (Bin bin : myValues) {
bin.resetOffsets(offset);
offset = offset + bin.sizeInBytes();
}
}
public int size() {
return myValues.length;
}
public Bin[] getArray() {
return myValues;
}
public T get(int index) {
//noinspection unchecked
return (T) myValues[index];
}
public long sizeInBytes() {
int size = 0;
for (Bin value : myValues) {
size += value.sizeInBytes();
}
return size;
}
public void read(DataInput stream) throws IOException {
init();
for (Bin value : myValues) {
value.read(stream);
}
}
public void write(DataOutput stream) throws IOException {
for (Bin value : myValues) {
value.write(stream);
}
}
public void report(OutputStreamWriter writer) throws IOException {
writer.write("\n" + "Array size: " + myValues.length);
for (Bin value : myValues) {
value.report(writer);
}
}
}
protected void _report(OutputStreamWriter buffer, String name, int value) throws IOException {
buffer.write("\n" + name + " : " + BitsUtil.intToHexString(value));
}
protected void _report(OutputStreamWriter buffer, String name, short value) throws IOException {
buffer.write("\n" + name + " : " + BitsUtil.shortToHexString(value));
}
protected void _report(OutputStreamWriter buffer, String name, byte value) throws IOException {
buffer.write("\n" + name + " : " + BitsUtil.byteToHexString(value));
}
protected void _report(OutputStreamWriter buffer, String message) throws IOException {
buffer.write("\n" + message);
}
}