Methods?

Author: Seggan

src/main/java/io/github/seggan/javaclasslib/JavaClass.java

@@ -3,6 +3,7 @@
 import io.github.seggan.javaclasslib.constantpool.ClassEntry;
 import io.github.seggan.javaclasslib.constantpool.ConstantPoolEntry;
 import io.github.seggan.javaclasslib.constantpool.UTF8Entry;
+import io.github.seggan.javaclasslib.methods.Method;
 
 import javax.annotation.Nonnull;
 import java.io.IOException;
@@ -21,7 +22,7 @@ public final class JavaClass {
     private final ClassEntry thisClass;
     private final ClassEntry superClass;
     private final int classVersion;
-
+    private final List<Method> methods = new LinkedList<>();
     private ClassAccessFlags[] classAccessFlags = new ClassAccessFlags[0];
 
     public JavaClass(@Nonnull String name, @Nonnull String superclass, int javaVersion) {
@@ -44,6 +45,12 @@ public void write(@Nonnull OutputStream out) throws IOException {
         out.write(ByteUtils.twoBytesFromInt(ClassAccessFlags.combine(classAccessFlags)));
         out.write(thisClass.getIndexBytes());
         out.write(superClass.getIndexBytes());
+        out.write(new byte[]{0, 0});
+        out.write(ByteUtils.twoBytesFromInt(methods.size()));
+        for (Method method : methods) {
+            out.write(method.getBytes());
+        }
+        out.write(0);
     }
 
     public List<ConstantPoolEntry> getConstantPool() {
@@ -69,4 +76,8 @@ public ClassAccessFlags[] getClassAccessFlags() {
     public void setClassAccessFlags(ClassAccessFlags... classAccessFlags) {
         this.classAccessFlags = classAccessFlags;
     }
+
+    public List<Method> getMethods() {
+        return methods;
+    }
 }

src/main/java/io/github/seggan/javaclasslib/attributes/code/CodeAttribute.java

@@ -1,16 +1,20 @@
 package io.github.seggan.javaclasslib.attributes.code;
 
 import com.google.common.primitives.Bytes;
+import io.github.seggan.javaclasslib.ByteUtils;
 import io.github.seggan.javaclasslib.attributes.Attribute;
 import io.github.seggan.javaclasslib.constantpool.UTF8Entry;
 
+import java.io.ByteArrayOutputStream;
+import java.util.List;
+
 public final class CodeAttribute extends Attribute {
 
     private final int maxStackSize;
     private final int maxLocalVarSize;
-    private final JvmInstructionImpl[] code;
+    private final List<JvmInstructionImpl> code;
 
-    public CodeAttribute(UTF8Entry nameIndex, int length, int maxStackSize, int maxLocalVarSize, JvmInstructionImpl... code) {
+    public CodeAttribute(UTF8Entry nameIndex, int length, int maxStackSize, int maxLocalVarSize, List<JvmInstructionImpl> code) {
         super(nameIndex, "Code", length);
         this.maxStackSize = maxStackSize;
         this.maxLocalVarSize = maxLocalVarSize;
@@ -19,7 +23,23 @@ public CodeAttribute(UTF8Entry nameIndex, int length, int maxStackSize, int maxL
 
     @Override
     public byte[] getBytes() {
-        return Bytes.concat();
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        for (JvmInstructionImpl instruction : code) {
+            for (byte b : instruction.getBytes()) {
+                outputStream.write(b);
+            }
+        }
+        byte[] codeByteArray = outputStream.toByteArray();
+
+        byte[] attribute = Bytes.concat(
+            ByteUtils.twoBytesFromInt(maxStackSize),
+            ByteUtils.twoBytesFromInt(maxLocalVarSize),
+            ByteUtils.intToBytes(codeByteArray.length),
+            codeByteArray,
+            new byte[]{0, 0, 0, 0}
+        );
+
+        return Bytes.concat(getNameIndex().getIndexBytes(), ByteUtils.intToBytes(attribute.length), attribute);
     }
 
     public int getMaxStackSize() {
@@ -30,7 +50,7 @@ public int getMaxLocalVarSize() {
         return maxLocalVarSize;
     }
 
-    public JvmInstructionImpl[] getCode() {
+    public List<JvmInstructionImpl> getCode() {
         return code;
     }
 }

src/main/java/io/github/seggan/javaclasslib/methods/Method.java

@@ -0,0 +1,58 @@
+package io.github.seggan.javaclasslib.methods;
+
+import com.google.common.primitives.Bytes;
+import io.github.seggan.javaclasslib.ByteUtils;
+import io.github.seggan.javaclasslib.attributes.Attribute;
+import io.github.seggan.javaclasslib.constantpool.UTF8Entry;
+
+import javax.annotation.Nonnull;
+import java.io.ByteArrayOutputStream;
+import java.util.ArrayList;
+import java.util.List;
+
+public final class Method {
+
+    private final UTF8Entry name;
+    private final UTF8Entry descriptor;
+    private final List<Attribute> attributes = new ArrayList<>();
+
+    private MethodAccessFlags[] accessFlags = new MethodAccessFlags[0];
+
+    public Method(UTF8Entry name, UTF8Entry descriptor) {
+        this.name = name;
+        this.descriptor = descriptor;
+    }
+
+    @Nonnull
+    public byte[] getBytes() {
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+        for (Attribute attribute : attributes) {
+            for (byte b : attribute.getBytes()) {
+                outputStream.write(b);
+            }
+        }
+
+        return Bytes.concat(ByteUtils.twoBytesFromInt(MethodAccessFlags.combine(accessFlags)), name.getIndexBytes(),
+            descriptor.getIndexBytes(), ByteUtils.twoBytesFromInt(attributes.size()), outputStream.toByteArray());
+    }
+
+    public UTF8Entry getName() {
+        return name;
+    }
+
+    public UTF8Entry getDescriptor() {
+        return descriptor;
+    }
+
+    public List<Attribute> getAttributes() {
+        return attributes;
+    }
+
+    public MethodAccessFlags[] getAccessFlags() {
+        return accessFlags;
+    }
+
+    public void setAccessFlags(MethodAccessFlags[] accessFlags) {
+        this.accessFlags = accessFlags;
+    }
+}

src/main/java/io/github/seggan/javaclasslib/methods/MethodAccessFlags.java

@@ -0,0 +1,32 @@
+package io.github.seggan.javaclasslib.methods;
+
+import java.util.Arrays;
+
+public enum MethodAccessFlags {
+    PUBLIC(0x0001),
+    PRIVATE(0x0002),
+    PROTECTED(0x0004),
+    STATIC(0x0008),
+    FINAL(0x0010),
+    SYNCHRONIZED(0x0020),
+    BRIDGE(0x0040),
+    VARAGRGS(0x0080),
+    NATIVE(0x0100),
+    ABSTRACT(0x0400),
+    STRICT(0x0800),
+    SYNTHETIC(0x1000);
+
+    private final int value;
+
+    MethodAccessFlags(int value) {
+        this.value = value;
+    }
+
+    public static int combine(MethodAccessFlags... flags) {
+        return Arrays.stream(flags).mapToInt(MethodAccessFlags::getValue).sum();
+    }
+
+    public int getValue() {
+        return value;
+    }
+}