src/Class.zig

@@ -36,8 +36,6 @@ 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,9 +319,7 @@ pub const AttributeInfo = union(enum) {
                             defer instr_indent -= 1;
 
                             try w.splatByteAll(' ', depth * instr_indent);
-                            try w.print("{d}:\n", .{ i });
+                            try w.print("{d}: 0x{x}\n", .{ i, instr });
-
-                            try instr.indentedFormat(w, depth, instr_indent + 1, constant_pool);
                         }
 
                         try w.splatByteAll(' ', depth * indent);
@@ -692,14 +690,12 @@ pub const ConstantValue = struct {
 pub const Code = struct {
     max_stack: u16,
     max_locals: u16,
-    code: []Instruction,
+    code: []u8,
     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,
@@ -740,20 +736,8 @@ pub const Code = struct {
         const max_locals = try input.takeInt(u16, .big);
 
         const code_length = try input.takeInt(u32, .big);
-        var code_reader_buf: [1024]u8 = undefined;
+        const code = try input.readAlloc(allocator, code_length);
-        var code_reader = input.limited(.limited(code_length), &code_reader_buf);
+        errdefer allocator.free(code);
-        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);
@@ -777,16 +761,13 @@ pub const Code = struct {
         return .{
             .max_stack = max_stack,
             .max_locals = max_locals,
-            .code = try instructions.toOwnedSlice(allocator),
+            .code = code,
             .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,52 +17,6 @@ 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