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))); }