katkak/java-class-parser
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Parse all op types

Browse source
This commit is contained in:
ktkk 2026-09-04 15:14:11 +00:00
parent 6944071b91
commit 176be5dad8
7 changed files with 1142 additions and 613 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/Class.zig
View file

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

27
src/Class/AttributeInfo.zig
View file

@ -319,7 +319,7 @@ pub const AttributeInfo = union(enum) {
defer instr_indent -= 1; defer instr_indent -= 1;
try w.splatByteAll(' ', depth * instr_indent); try w.splatByteAll(' ', depth * instr_indent);
try w.print("{d}: 0x{x}\n", .{ i, instr }); try w.print("{d}: {t}\n", .{ i, instr });
} }
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -690,12 +690,14 @@ pub const ConstantValue = struct {
pub const Code = struct { pub const Code = struct {
max_stack: u16, max_stack: u16,
max_locals: u16, max_locals: u16,
code: []u8, code: []Instruction,
exception_table: []ExceptionHandler, exception_table: []ExceptionHandler,
attributes: []AttributeInfo, attributes: []AttributeInfo,
const Self = @This(); const Self = @This();
pub const Instruction = @import("Code/Instruction.zig").Instruction;
pub const ExceptionHandler = struct { pub const ExceptionHandler = struct {
start_pc: u16, start_pc: u16,
end_pc: u16, end_pc: u16,
@ -736,8 +738,20 @@ pub const Code = struct {
const max_locals = try input.takeInt(u16, .big); const max_locals = try input.takeInt(u16, .big);
const code_length = try input.takeInt(u32, .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_length = try input.takeInt(u16, .big);
const exception_table = try allocator.alloc(ExceptionHandler, exception_table_length); const exception_table = try allocator.alloc(ExceptionHandler, exception_table_length);
@ -761,13 +775,16 @@ pub const Code = struct {
return .{ return .{
.max_stack = max_stack, .max_stack = max_stack,
.max_locals = max_locals, .max_locals = max_locals,
.code = code, .code = try instructions.toOwnedSlice(allocator),
.exception_table = exception_table, .exception_table = exception_table,
.attributes = attributes, .attributes = attributes,
}; };
} }
pub fn deinit(self: *Self, allocator: std.mem.Allocator) void { pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
for (self.code) |*instruction| {
instruction.deinit(allocator);
}
allocator.free(self.code); allocator.free(self.code);
allocator.free(self.exception_table); allocator.free(self.exception_table);
for (self.attributes) |*attr| { for (self.attributes) |*attr| {

26
src/Class/AttributeInfo/Code.zig
View file

@ -1,26 +0,0 @@
const std = @import("std");
const Class = @import("../../Class.zig");
const AttributeInfo = Class.AttributeInfo;
const ParseError = Class.ParseError;
const Instructions = @import("Instructions.zig").Instructions;
max_stack: u16,
max_locals: u16,
code: []Instructions,
exception_table: []ExceptionHandler,
attributes: []AttributeInfo,
const Self = @This();
pub const ExceptionHandler = struct {
start_pc: u16,
end_pc: u16,
handler_pc: u16,
catch_type: u16,
};
pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!Self {
}

582
src/Class/AttributeInfo/Instructions.zig
View file

@ -1,582 +0,0 @@
const std = @import("std");
const InstructionSet = enum(u8) {
aaload = 0x32,
aastore = 0x53,
aconst_null = 0x1,
aload = 0x19,
aload_0 = 0x2a,
aload_1 = 0x2b,
aload_2 = 0x2c,
aload_3 = 0x2d,
anewarray = 0xbd,
areturn = 0xb0,
arraylength = 0xbe,
astore = 0x3a,
astore_0 = 0x4b,
astore_1 = 0x4c,
astore_2 = 0x4d,
astore_3 = 0x4e,
athrow = 0xbf,
baload = 0x33,
bastore = 0x54,
bipush = 0x10,
caload = 0x34,
castore = 0x55,
checkcast = 0xc0,
d2f = 0x90,
d2i = 0x8e,
d2l = 0x8f,
dadd = 0x63,
daload = 0x31,
dastore = 0x52,
dcmpg = 0x98,
dcmpl = 0x97,
dconst_0 = 0xe,
dconst_1 = 0xf,
ddiv = 0x6f,
dload = 0x18,
dload_0 = 0x26,
dload_1 = 0x27,
dload_2 = 0x28,
dload_3 = 0x29,
dmul = 0x6b,
dneg = 0x77,
drem = 0x73,
dreturn = 0xaf,
dstore = 0x39,
dstore_0 = 0x47,
dstore_1 = 0x48,
dstore_2 = 0x49,
dstore_3 = 0x4a,
dsub = 0x67,
dup = 0x59,
dup_x1 = 0x5a,
dup_x2 = 0x5b,
dup2 = 0x5c,
dup2_x1 = 0x5d,
dup2_x2 = 0x5e,
f2d = 0x8d,
f2i = 0x8b,
f2l = 0x8c,
fadd = 0x62,
faload = 0x30,
fastore = 0x51,
fcmpg = 0x96,
fcmpl = 0x95,
fconst_0 = 0xb,
fconst_1 = 0xc,
fconst_2 = 0xd,
fdiv = 0x6e,
fload = 0x17,
fload_0 = 0x22,
fload_1 = 0x23,
fload_2 = 0x24,
fload_3 = 0x25,
fmul = 0x6a,
fneg = 0x76,
frem = 0x72,
freturn = 0xae,
fstore = 0x38,
fstore_0 = 0x43,
fstore_1 = 0x44,
fstore_2 = 0x45,
fstore_3 = 0x46,
fsub = 0x66,
getfield = 0xb4,
getstatic = 0xb2,
goto = 0xa7,
goto_w = 0xc8,
i2b = 0x91,
i2c = 0x92,
i2d = 0x87,
i2f = 0x86,
i2l = 0x85,
i2s = 0x93,
iadd = 0x60,
iaload = 0x2e,
iand = 0x7e,
iastore = 0x4f,
iconst_m1 = 0x2,
iconst_0 = 0x3,
iconst_1 = 0x4,
iconst_2 = 0x5,
iconst_3 = 0x6,
iconst_4 = 0x7,
iconst_5 = 0x8,
idiv = 0x6c,
if_acmpeq = 0xa5,
if_acmpne = 0xa6,
if_icmpeq = 0x9f,
if_icmpne = 0xa0,
if_icmplt = 0xa1,
if_icmpge = 0xa2,
if_icmpgt = 0xa3,
if_icmple = 0xa4,
ifeq = 0x99,
ifne = 0x9a,
iflt = 0x9b,
ifge = 0x9c,
ifgt = 0x9d,
ifle = 0x9e,
ifnonnull = 0xc7,
ifnull = 0xc6,
iinc = 0x84,
iload = 0x15,
iload_0 = 0x1a,
iload_1 = 0x1b,
iload_2 = 0x1c,
iload_3 = 0x1d,
imul = 0x68,
ineg = 0x74,
instanceof = 0xc1,
invokedynamic = 0xba,
invokeinterface = 0xb9,
invokespecial = 0xb7,
invokestatic = 0xb8,
invokevirtual = 0xb6,
ior = 0x80,
irem = 0x70,
ireturn = 0xac,
ishl = 0x78,
ishr = 0x7a,
istore = 0x36,
istore_0 = 0x3b,
istore_1 = 0x3c,
istore_2 = 0x3d,
istore_3 = 0x3e,
isub = 0x64,
iushr = 0x7c,
ixor = 0x82,
jsr = 0xa8,
jsr_2 = 0xc9,
l2d = 0x8a,
l2f = 0x89,
l2i = 0x88,
ladd = 0x61,
laload = 0x2f,
land = 0x7f,
lastore = 0x50,
lcmp = 0x94,
lconst_0 = 0x9,
lconst_1 = 0xa,
ldc = 0x12,
ldc_2 = 0x13,
ldc2_w = 0x14,
ldiv = 0x6d,
lload = 0x16,
lload_0 = 0x1e,
lload_1 = 0x1f,
lload_2 = 0x20,
lload_3 = 0x21,
lmul = 0x69,
lneg = 0x75,
lookupswitch = 0xab,
lor = 0x81,
lrem = 0x71,
lreturn = 0xad,
lshl = 0x79,
lshr = 0x7b,
lstore = 0x37,
lstore_0 = 0x3f,
lstore_1 = 0x40,
lstore_2 = 0x41,
lstore_3 = 0x42,
lsub = 0x65,
lushr = 0x7d,
lxor = 0x83,
monitorenter = 0xc2,
monitorexit = 0xc3,
multianewarray = 0xc5,
new = 0xbb,
newarray = 0xbc,
nop = 0x0,
pop = 0x57,
pop2 = 0x58,
putfield = 0xb5,
putstatic = 0xb3,
ret = 0xa9,
@"return" = 0xb1,
saload = 0x35,
sastore = 0x56,
sipush = 0x11,
swap = 0x5f,
tableswitch = 0xaa,
wide = 0xc4,
};
const IndexU8 = struct {
index: u8,
};
const IndexU16 = struct {
index: u16,
const Self = @This();
pub fn from(b1: u8, b2: u8) Self {
return .{ .index = (b1 << 8) | b2 };
}
};
const IndexU32 = struct {
index: u32,
const Self = @This();
pub fn from(b1: u8, b2: u8, b3: u8, b4: u8) Self {
return .{ .index = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4 };
}
};
const Byte = struct {
byte: u8,
};
const BranchU16 = struct {
branch: u16,
const Self = @This();
pub fn from(b1: u8, b2: u8) Self {
return .{ .index = (b1 << 8) | b2 };
}
};
const BranchU32 = struct {
branch: u32,
const Self = @This();
pub fn from(b1: u8, b2: u8, b3: u8, b4: u8) Self {
return .{ .branch = (b1 << 24) | (b2 << 16) | (b3 << 8) | b4 };
}
};
const IInc = struct {
index: u8,
@"const": u8,
};
const InvokeDynamic = struct {
index: u16,
const Self = @This();
pub fn from(b1: u8, b2: u8, pad1: u8, pad2: u8) Self {
_ = pad1;
_ = pad2;
return .{ .index = (b1 << 8) | b2 };
}
};
const InvokeInterface = struct {
index: u16,
count: u8,
const Self = @This();
pub fn from(b1: u8, b2: u8, count: u8, pad: u8) Self {
_ = pad;
return .{ .index = (b1 << 8) | b2, .count = count };
}
};
const LookupSwitch = struct {
default: i32,
pairs: []Pair,
const Pair = struct {
match: u32,
offset: i32,
};
};
const MultiANewArray = struct {
index: u16,
dimensions: u8,
const Self = @This();
pub fn from(b1: u8, b2: u8, dimensions: u8) Self {
return .{ .index = (b1 << 8) | b2, .dimensions = dimensions };
}
};
const NewArray = struct {
array_type: ArrayType,
const Self = @This();
const ArrayType = enum(u8) {
boolean = 4,
char = 5,
float = 6,
double = 7,
byte = 8,
short = 9,
int = 10,
long = 11,
};
pub fn from(atype: u8) Self {
const array_type = std.enums.fromInt(ArrayType, atype) orelse {
std.log.err("Invalid array type");
std.process.exit(1);
};
return .{ .array_type = array_type };
}
};
const Short = struct {
short: u16,
const Self = @This();
pub fn from(b1: u8, b2: u8) Self {
return .{ .short = (b1 << 8) | b2 };
}
};
const TableSwitch = struct {
default: i32,
low: i32,
hight: i32,
offsets: []i32,
};
const Wide = union {
form1: struct {
opcode: ModifiableInstruction,
index: u16,
},
form2: struct {
// Should always be iinc
opcode: ModifiableInstruction,
index: u16,
@"const": u16,
},
const Self = @This();
const ModifiableInstruction = enum(u8) {
iload = 0x15,
fload = 0x17,
aload = 0x19,
lload = 0x16,
dload = 0x18,
istore = 0x36,
fstore = 0x38,
astore = 0x3a,
lstore = 0x37,
dstore = 0x39,
ret = 0xa9,
iinc = 0x84,
};
};
const Instructions = union(InstructionSet) {
aaload,
aastore,
aconst_null,
aload: IndexU8,
aload_0,
aload_1,
aload_2,
aload_3,
anewarray: IndexU16,
areturn,
arraylength,
astore: IndexU8,
astore_0,
astore_1,
astore_2,
astore_3,
athrow,
baload,
bastore,
bipush: Byte,
caload,
castore,
checkcast: IndexU16,
d2f,
d2i,
d2l,
dadd,
daload,
dastore,
dcmpg,
dcmpl,
dconst_0,
dconst_1,
ddiv,
dload: IndexU8,
dload_0,
dload_1,
dload_2,
dload_3,
dmul,
dneg,
drem,
dreturn,
dstore: IndexU8,
dstore_0,
dstore_1,
dstore_2,
dstore_3,
dsub,
dup,
dup_x1,
dup_x2,
dup2,
dup2_x1,
dup2_x2,
f2d,
f2i,
f2l,
fadd,
faload,
fastore,
fcmpg,
fcmpl,
fconst_0,
fconst_1,
fconst_2,
fdiv,
fload: IndexU8,
fload_0,
fload_1,
fload_2,
fload_3,
fmul,
fneg,
frem,
freturn,
fstore: IndexU8,
fstore_0,
fstore_1,
fstore_2,
fstore_3,
fsub,
getfield: IndexU16,
getstatic: IndexU16,
goto: IndexU16,
goto_w: IndexU32,
i2b,
i2c,
i2d,
i2f,
i2l,
i2s,
iadd,
iaload,
iand,
iastore,
iconst_m1,
iconst_0,
iconst_1,
iconst_2,
iconst_3,
iconst_4,
iconst_5,
idiv,
if_acmpeq: BranchU16,
if_acmpne: BranchU16,
if_icmpeq: BranchU16,
if_icmpne: BranchU16,
if_icmplt: BranchU16,
if_icmpge: BranchU16,
if_icmpgt: BranchU16,
if_icmple: BranchU16,
ifeq: BranchU16,
ifne: BranchU16,
iflt: BranchU16,
ifge: BranchU16,
ifgt: BranchU16,
ifle: BranchU16,
ifnonnull: BranchU16,
ifnull: BranchU16,
iinc: IInc,
iload: IndexU8,
iload_0,
iload_1,
iload_2,
iload_3,
imul,
ineg,
instanceof: IndexU16,
invokedynamic: InvokeDynamic,
invokeinterface: InvokeInterface,
invokespecial: IndexU16,
invokestatic: IndexU16,
invokevirtual: IndexU16,
ior,
irem,
ireturn,
ishl,
ishr,
istore: IndexU8,
istore_0,
istore_1,
istore_2,
istore_3,
isub,
iushr,
ixor,
jsr: BranchU16,
jsr_w: BranchU32,
l2d,
l2f,
l2i,
ladd,
laload,
land,
lastore,
lcmp,
lconst_0,
lconst_1,
ldc: IndexU8,
ldc_w: IndexU16,
ldc2_w: IndexU16,
ldiv,
lload: IndexU8,
lload_0,
lload_1,
lload_2,
lload_3,
lmul,
lneg,
lookupswitch: LookupSwitch,
lor,
lrem,
lreturn,
lshl,
lshr,
lstore: IndexU8,
lstore_0,
lstore_1,
lstore_2,
lstore_3,
lsub,
lushr,
lxor,
monitorenter,
monitorexit,
mulitanewarray: MultiANewArray,
new: IndexU16,
newarray: NewArray,
nop,
pop,
pop2,
putfield: IndexU16,
putstatic: IndexU16,
ret: IndexU8,
@"return",
saload,
sastore,
sipush: Short,
swap,
tableswitch: TableSwitch,
wide: Wide,
};

1072
src/Class/Code/Instruction.zig Normal file
View file

File diff suppressed because it is too large Load diff

46
testsuite/classes/java/Main.java
View file

@ -17,6 +17,52 @@ public class Main implements Runnable, Supplier<Integer>, Interface {
} finally { } finally {
System.err.println("Finally block"); 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 @Override

BIN
testsuite/classes/java/Object.class
View file

Binary file not shown.