public void FieldsTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.SimpleModel));
var image = new JavaClassImage(classFile);
Assert.Equal(3, image.RootClass.Fields.Count);
}
public void SuperClassTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.SimpleModel));
var image = new JavaClassImage(classFile);
Assert.Equal("java/lang/Object", image.RootClass.SuperClass.Name);
}
public void AccessFlagsTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.SimpleModel));
var image = new JavaClassImage(classFile);
Assert.Equal(ClassAccessFlags.Public | ClassAccessFlags.Super, image.RootClass.AccessFlags);
}
public JavaClassImage(JavaClassFile classFile)
{
ClassFile = classFile;
RootClass = new ClassDefinition(this);
MajorVersion = classFile.MajorVersion;
MinorVersion = classFile.MinorVersion;
// Attributes
foreach (var attr in classFile.Attributes)
{
string name = classFile.ConstantPool.ResolveString(attr.NameIndex);
switch (name)
{
// Source file
case SingleIndexAttribute.SourceFileAttribute:
_sourceFile = new LazyValue <string>(() =>
{
var sourceFile = SingleIndexAttribute.FromReader(name, new MemoryBigEndianReader(attr.Contents));
return(classFile.ConstantPool.ResolveString(sourceFile.ConstantPoolIndex));
});
break;
case BootstrapMethodsAttribute.AttributeName:
_bootstrapMethodsAttribute = BootstrapMethodsAttribute.FromReader(new MemoryBigEndianReader(attr.Contents));
break;
default:
ExtraAttributes.Add(name, attr.Clone());
break;
}
}
}
public CodeAttr(UInt16 name_index, UInt32 att_length, byte[] data, JavaClassFile fileParser)
: base(name_index, att_length)
{
this.MaxStack = BitConverter.ToUInt16(data.Take(2).Reverse().ToArray(), 0);
this.MaxLocals = BitConverter.ToUInt16(data.Skip(2).Take(2).Reverse().ToArray(), 0);
var codeLength = BitConverter.ToUInt32(data.Skip(4).Take(4).Reverse().ToArray(), 0);
this.ByteCodes = data.Skip(8).Take((int)codeLength).ToArray();
var exTableLength = BitConverter.ToUInt16(data.Skip((int)codeLength + 8).Take(2).Reverse().ToArray(), 0);
int startIndex = (int)codeLength + 10;
for (int i = 0; i < exTableLength; i++)
{
var exEnity = new ExceptionEntity(data.Skip(startIndex).Take(8).ToArray());
startIndex += 8;
EX_table.Add(exEnity);
}
var attCount = BitConverter.ToUInt16(data.Skip(startIndex).Take(2).Reverse().ToArray(), 0);
startIndex += 2;
for (int i = 0; i < attCount; i++)
{
var nameIndex = BitConverter.ToUInt16(data.Skip(startIndex).Take(2).Reverse().ToArray(), 0);
//var type = ((UTF8_CP)jvm.ConstantPools[nameIndex]).DataString;
startIndex += 2;
var attlength = BitConverter.ToUInt32(data.Skip(startIndex).Take(4).Reverse().ToArray(), 0);
startIndex += 4;
var source = data.Skip(startIndex).Take((int)attlength).ToArray();
ATT_list.Add(fileParser.ParseAttribute(nameIndex, attlength, source));
startIndex += (int)attlength;
}
}
public JavaClassImage(JavaClassFile classFile)
{
ClassFile = classFile;
RootClass = new ClassDefinition(this);
MajorVersion = classFile.MajorVersion;
MinorVersion = classFile.MinorVersion;
}
public MethodDefinitionTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.SimpleModel));
var image = new JavaClassImage(classFile);
var classDef = image.RootClass;
_constructor = classDef.Methods.FirstOrDefault(x => x.Name == "<init>");
}
public FieldDefinitionTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.SimpleModel));
var image = new JavaClassImage(classFile);
var classDef = image.RootClass;
_myIntField = classDef.Fields.FirstOrDefault(x => x.Name == "myIntField");
_myStringField = classDef.Fields.FirstOrDefault(x => x.Name == "myStringField");
_myModelField = classDef.Fields.FirstOrDefault(x => x.Name == "myModelField");
}
public void ExceptionsTest()
{
var classFile = JavaClassFile.FromReader(new MemoryBigEndianReader(Properties.Resources.Exceptions));
var image = new JavaClassImage(classFile);
var classDef = image.RootClass;
var throwsMethod = classDef.Methods.First(x => x.Name == "Throws");
Assert.Single(throwsMethod.Exceptions);
Assert.Equal("CustomException", throwsMethod.Exceptions[0].Name);
}
private static JavaClassImage DumpImage(JavaClassFile classFile)
{
var image = new JavaClassImage(classFile);
var rootClass = image.RootClass;
Console.WriteLine("Basic information:");
DumpStructure(rootClass);
Console.WriteLine("Disassembly of each method:");
DumpByteCode(rootClass);
return(image);
}
public JavaClassFile CreateClassFile(JavaClassImage image)
{
var context = new BuildingContext(this);
// Basic structure.
var file = new JavaClassFile
{
MajorVersion = image.MajorVersion,
MinorVersion = image.MinorVersion,
};
var thisReference = new ClassReference(image.RootClass.Name);
file.ThisClass = (ushort)ConstantPoolBuffer.GetClassIndex(thisReference);
if (image.RootClass.SuperClass != null)
{
file.SuperClass = (ushort)ConstantPoolBuffer.GetClassIndex(image.RootClass.SuperClass);
}
file.AccessFlags = image.RootClass.AccessFlags;
// Fields
foreach (var field in image.RootClass.Fields)
{
file.Fields.Add(CreateFieldInfo(context, field));
}
// Methods
foreach (var method in image.RootClass.Methods)
{
file.Methods.Add(CreateMethodInfo(context, method));
}
// Source file
if (image.SourceFile != null)
{
file.Attributes.Add(CreateAttribute(context, new SingleIndexAttribute(
SingleIndexAttribute.SourceFileAttribute,
(ushort)ConstantPoolBuffer.GetUtf8Index(image.SourceFile))));
}
if (BootstrapMethodsAttribute.BootstrapMethods.Count > 0)
{
file.Attributes.Add(CreateAttribute(context, BootstrapMethodsAttribute));
}
AddAttributes(context, file, image);
file.ConstantPool = ConstantPoolBuffer.CreateConstantPool();
return(file);
}
public static void Main(string[] args)
{
string path = args[0].Replace("\"", "");
var classFile = JavaClassFile.FromFile(path);
var image = new JavaClassImage(classFile);
var rootClass = image.RootClass;
Console.WriteLine("Basic information:");
DumpStructure(rootClass);
Console.WriteLine("Disassembly of each method:");
DumpByteCode(rootClass);
}
public void NoChange()
{
var reader = new MemoryBigEndianReader(Resources.HelloWorld);
var classFile = JavaClassFile.FromReader(reader);
using (var stream = new MemoryStream())
{
var writer = new BigEndianStreamWriter(stream);
classFile.Write(new WritingContext(writer));
Assert.Equal(Resources.HelloWorld, stream.ToArray());
}
}
public void Save()
{
Logger.Info("Trying to save the result");
try
{
JavaClassFile classFile = Image.CreateClassFile();
classFile.Write(this.OutputPath);
Logger.Successed("File saved to: " + this.OutputPath);
}
catch (Exception ex)
{
Logger.Failed("Couldn't save the file for reasons: " + ex.Message);
}
}
/// <summary>
/// Builds the class image and verifies the output of the file.
/// </summary>
/// <param name="image">The class to compile.</param>
/// <param name="expectedOutput">The expected output of the file.</param>
/// <param name="regex">Specifies if <paramref name="expectedOutput"/> should be interpreted as a regular expression pattern.</param>
public void WriteAndVerifyOutput(JavaClassFile classFile, string expectedOutput, bool regex = false)
{
var classInfo = (ClassInfo)classFile.ConstantPool.ResolveConstant(classFile.ThisClass);
string name = classFile.ConstantPool.ResolveString(classInfo.NameIndex);
using (var fs = File.Create(Path.Combine(OutputDirectory, name + ".class")))
{
var writer = new BigEndianStreamWriter(fs);
var context = new WritingContext(writer);
classFile.Write(context);
}
VerifyOutput(name, expectedOutput, regex);
}
public LineNumAttr(UInt16 name_index, UInt32 att_length, byte[] data, JavaClassFile fileParser)
: base(name_index, att_length)
{
var lineTableCount = BitConverter.ToUInt16(data.Take(2).Reverse().ToArray(), 0);
var start = 2;
for (int i = 0; i < lineTableCount; i++)
{
var start_pc = BitConverter.ToUInt16(data.Skip(start).Take(2).Reverse().ToArray(), 0);
start += 2;
var line_number = BitConverter.ToUInt16(data.Skip(start).Take(2).Reverse().ToArray(), 0);
start += 2;
line_number_table.Add(new Tuple <UInt16, UInt16>(start_pc, line_number));
}
}
public static void Main(string[] args)
{
string path = args[0].Replace("\"", "");
var classFile = JavaClassFile.FromFile(path);
classFile.MajorVersion = 52;
var image = DumpImage(classFile);
var newClassFile = image.CreateClassFile();
string outputPath = Path.Combine(Path.GetDirectoryName(path), "output", Path.GetFileName(path));
newClassFile.Write(outputPath);
newClassFile = JavaClassFile.FromFile(outputPath);
DumpImage(newClassFile);
}
public JavaClass(JavaClassFile jcf, VmContiner continerLoader)
{
classFile = jcf;
this.ClassLoader = continerLoader;
Convert();
}
/// <summary>
/// Parses a class file located on tbhe disk, and opens a high-level representation of the class file.
/// </summary>
/// <param name="file">The path to the file to parse.</param>
/// <returns>The high-level Java class image.</returns>
/// <exception cref="BadImageFormatException">Occurs when the file does not provide a valid signature of
/// a class file.</exception>
public static JavaClassImage FromFile(string file)
{
return(new JavaClassImage(JavaClassFile.FromFile(file)));
}
/// <summary>
/// Parses a class file from a binary reader and opens a high-level representation of the class file.
/// </summary>
/// <param name="reader">The reader to read from.</param>
/// <returns>The high-level Java class image.</returns>
/// <exception cref="BadImageFormatException">Occurs when the file does not provide a valid signature of
/// a class file.</exception>
public static JavaClassImage FromReader(IBigEndianReader reader)
{
return(new JavaClassImage(JavaClassFile.FromReader(reader)));
}
