Merge pull request 'feature/instructions' (#1) from feature/instructions into master

Reviewed-on: #1

src/Class.zig

@@ -36,6 +36,8 @@ pub const ClassAccessFlags = EnumFlags(enum(u16) {
 pub const ParseError = std.Io.Reader.Error || std.mem.Allocator.Error || error {
     InvalidMagicNumber,
     InvalidTag,
+    InvalidOp,
+    InvalidArrayType,
 };
 
 pub const ResolveError = error {

src/Class/AttributeInfo.zig

@@ -319,20 +319,22 @@ pub const AttributeInfo = union(enum) {
                             defer instr_indent -= 1;
 
                             try w.splatByteAll(' ', depth * instr_indent);
-                            try w.print("{d}: 0x{x}\n", .{ i, instr });
+                            try w.print("{d}:\n", .{ i });
+
+                            try instr.indentedFormat(w, depth, instr_indent + 1, constant_pool);
                         }
 
                         try w.splatByteAll(' ', depth * indent);
                         _ = try w.write("exception_table:\n");
                         var exception_indent = indent;
                         for (attr.exception_table, 0..) |*exception, i| {
-                           exception_indent += 1;
+                            exception_indent += 1;
-                           defer exception_indent -= 1;
+                            defer exception_indent -= 1;
 
-                           try w.splatByteAll(' ', depth * exception_indent);
+                            try w.splatByteAll(' ', depth * exception_indent);
-                           try w.print("{d}:\n", .{ i });
+                            try w.print("{d}:\n", .{ i });
 
-                           try exception.indentedFormat(w, depth, exception_indent + 1, constant_pool);
+                            try exception.indentedFormat(w, depth, exception_indent + 1, constant_pool);
                         }
 
                         try w.splatByteAll(' ', depth * indent);
@@ -690,12 +692,14 @@ pub const ConstantValue = struct {
 pub const Code = struct {
     max_stack: u16,
     max_locals: u16,
-    code: []u8,
+    code: []Instruction,
     exception_table: []ExceptionHandler,
     attributes: []AttributeInfo,
 
     const Self = @This();
 
+    pub const Instruction = @import("Code/Instruction.zig").Instruction;
+
     pub const ExceptionHandler = struct {
         start_pc: u16,
         end_pc: u16,
@@ -736,8 +740,20 @@ pub const Code = struct {
         const max_locals = try input.takeInt(u16, .big);
 
         const code_length = try input.takeInt(u32, .big);
-        const code = try input.readAlloc(allocator, code_length);
+        var code_reader_buf: [1024]u8 = undefined;
-        errdefer allocator.free(code);
+        var code_reader = input.limited(.limited(code_length), &code_reader_buf);
+        var code = &code_reader.interface;
+        var byte_index: usize = 0;
+        var instructions: std.ArrayList(Instruction) = .empty;
+        defer instructions.deinit(allocator);
+        loop: while (true) {
+            _ = code.peekByte() catch |err| switch (err) {
+                error.EndOfStream => break :loop,
+                else => return err,
+            };
+
+            try instructions.append(allocator, try .parse(code, allocator, &byte_index));
+        }
 
         const exception_table_length = try input.takeInt(u16, .big);
         const exception_table = try allocator.alloc(ExceptionHandler, exception_table_length);
@@ -761,13 +777,16 @@ pub const Code = struct {
         return .{
             .max_stack = max_stack,
             .max_locals = max_locals,
-            .code = code,
+            .code = try instructions.toOwnedSlice(allocator),
             .exception_table = exception_table,
             .attributes = attributes,
         };
     }
 
     pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
+        for (self.code) |*instruction| {
+            instruction.deinit(allocator);
+        }
         allocator.free(self.code);
         allocator.free(self.exception_table);
         for (self.attributes) |*attr| {

testsuite/classes/java/Main.java

@@ -17,6 +17,52 @@ public class Main implements Runnable, Supplier<Integer>, Interface {
         } finally {
             System.err.println("Finally block");
         }
+
+        var a = 8;
+        a <<= 3;
+        final var b = a >> 1;
+        switch (b) {
+            case 1:
+                break;
+            case 32:
+                System.out.println("Good");
+                break;
+            default:
+                System.out.println("Number " + a);
+                break;
+        }
+
+        final var o = getObject();
+        switch (o) {
+            case Integer i:
+                switch (i) {
+                    case 1:
+                        System.out.println("One");
+                        break;
+                    case 2:
+                        System.out.println("Two");
+                        break;
+                    case 3:
+                        System.out.println("Three");
+                        break;
+                    default:
+                        break;
+                }
+                break;
+            default:
+                System.out.println("Something else");
+                break;
+        }
+
+        inc(5);
+    }
+
+    private static Object getObject() {
+        return 3;
+    }
+
+    private static void inc(int i) {
+        i += 1000;
     }
 
     @Override