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

Refactor constant pool

Browse source
This commit is contained in:
ktkk 2026-07-05 23:29:37 +02:00
parent 9135e95dbd
commit 146d90ccec
6 changed files with 257 additions and 500 deletions
Download patch file Download diff file Expand all files Collapse all files

73
src/Class.zig
View file

@ -12,7 +12,7 @@ allocator: std.mem.Allocator,
magic: u32, magic: u32,
minor_version: u16, minor_version: u16,
major_version: u16, major_version: u16,
constant_pool: []?ConstantPool.Info, constant_pool: ConstantPool,
access_flags: ClassAccessFlags, access_flags: ClassAccessFlags,
this_class: u16, this_class: u16,
super_class: u16, super_class: u16,
@ -54,13 +54,8 @@ pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) (ParseError ||
const minor_version = try input.takeInt(u16, .big); const minor_version = try input.takeInt(u16, .big);
const major_version = try input.takeInt(u16, .big); const major_version = try input.takeInt(u16, .big);
const constant_pool = try parseConstantPool(input, allocator); var constant_pool: ConstantPool = try .parse(input, allocator);
errdefer { errdefer constant_pool.deinit(allocator);
for (constant_pool) |*cp_info| {
if (cp_info.*) |*c| c.deinit(allocator);
}
allocator.free(constant_pool);
}
const access_flags: ClassAccessFlags = .{ .mask = try input.takeInt(u16, .big) }; const access_flags: ClassAccessFlags = .{ .mask = try input.takeInt(u16, .big) };
@ -110,30 +105,6 @@ pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) (ParseError ||
}; };
} }
fn parseConstantPool(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]?ConstantPool.Info {
const constant_pool_size = try input.takeInt(u16, .big);
const constant_pool = try allocator.alloc(?ConstantPool.Info, constant_pool_size - 1);
errdefer allocator.free(constant_pool);
var i: usize = 0;
while (i < constant_pool_size - 1) {
defer i += 1;
const cp_info = try ConstantPool.Info.parse(input, allocator);
constant_pool[i] = cp_info;
switch (cp_info) {
.long, .double => {
i += 1;
constant_pool[i] = null;
},
else => {},
}
}
return constant_pool;
}
fn parseInterfaces(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]u16 { fn parseInterfaces(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError![]u16 {
const interfaces_count = try input.takeInt(u16, .big); const interfaces_count = try input.takeInt(u16, .big);
const interfaces = try allocator.alloc(u16, interfaces_count); const interfaces = try allocator.alloc(u16, interfaces_count);
@ -146,7 +117,7 @@ fn parseInterfaces(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseErr
return interfaces; return interfaces;
} }
fn parseFields(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)![]FieldInfo { fn parseFields(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)![]FieldInfo {
const fields_count = try input.takeInt(u16, .big); const fields_count = try input.takeInt(u16, .big);
const fields = try allocator.alloc(FieldInfo, fields_count); const fields = try allocator.alloc(FieldInfo, fields_count);
errdefer allocator.free(fields); errdefer allocator.free(fields);
@ -158,19 +129,19 @@ fn parseFields(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info,
return fields; return fields;
} }
fn parseMethods(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)![]MethodInfo { fn parseMethods(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)![]MethodInfo {
const methods_count = try input.takeInt(u16, .big); const methods_count = try input.takeInt(u16, .big);
const methods = try allocator.alloc(MethodInfo, methods_count); const methods = try allocator.alloc(MethodInfo, methods_count);
errdefer allocator.free(methods); errdefer allocator.free(methods);
for (0..methods_count) |i| { for (0..methods_count) |i| {
methods[i] = try MethodInfo.parse(input, constant_pool, allocator); methods[i] = try .parse(input, constant_pool, allocator);
} }
return methods; return methods;
} }
pub fn parseAttributes(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)![]AttributeInfo { pub fn parseAttributes(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)![]AttributeInfo {
const attributes_count = try input.takeInt(u16, .big); const attributes_count = try input.takeInt(u16, .big);
const attributes = try allocator.alloc(AttributeInfo, attributes_count); const attributes = try allocator.alloc(AttributeInfo, attributes_count);
errdefer allocator.free(attributes); errdefer allocator.free(attributes);
@ -183,20 +154,13 @@ pub fn parseAttributes(input: *std.Io.Reader, constant_pool: []const ?ConstantPo
} }
pub fn deinit(self: *Self) void { pub fn deinit(self: *Self) void {
self.freeConstantPool(); self.constant_pool.deinit(self.allocator);
self.freeInterfaces(); self.freeInterfaces();
self.freeFields(); self.freeFields();
self.freeMethods(); self.freeMethods();
self.freeAttributes(); self.freeAttributes();
} }
fn freeConstantPool(self: *Self) void {
for (self.constant_pool) |*cp_info| {
if (cp_info.*) |*c| c.deinit(self.allocator);
}
self.allocator.free(self.constant_pool);
}
fn freeInterfaces(self: *Self) void { fn freeInterfaces(self: *Self) void {
self.allocator.free(self.interfaces); self.allocator.free(self.interfaces);
} }
@ -258,13 +222,11 @@ pub fn format(self: *const Self, w: *std.Io.Writer) std.Io.Writer.Error!void {
indent += 1; indent += 1;
defer indent -= 1; defer indent -= 1;
if (interface >= self.constant_pool.len) return error.WriteFailed; const info = self.constant_pool.getTag(interface, .class) catch return error.WriteFailed;
const cp_info = self.constant_pool[interface - 1];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, indent + 1, self.constant_pool); try info.indentedFormat(w, depth, indent + 1, self.constant_pool);
} }
_ = try w.write("fields:\n"); _ = try w.write("fields:\n");
@ -299,11 +261,7 @@ pub fn format(self: *const Self, w: *std.Io.Writer) std.Io.Writer.Error!void {
} }
pub fn thisClass(self: *const Self) ResolveError!ConstantPool.Info { pub fn thisClass(self: *const Self) ResolveError!ConstantPool.Info {
const this_class = self.this_class - 1; return self.constant_pool.getTag(self.this_class, .class);
if (this_class >= self.constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = self.constant_pool[this_class];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn superClass(self: *const Self) ResolveError!?ConstantPool.Info { pub fn superClass(self: *const Self) ResolveError!?ConstantPool.Info {
@ -313,17 +271,14 @@ pub fn superClass(self: *const Self) ResolveError!?ConstantPool.Info {
if (!std.mem.eql(u8, this_class_name.bytes, "java/lang/Object")) return ResolveError.InvalidConstantType; if (!std.mem.eql(u8, this_class_name.bytes, "java/lang/Object")) return ResolveError.InvalidConstantType;
return null; return null;
} else { } else {
const super_class = self.super_class - 1; const super_class = try self.constant_pool.getTag(self.super_class, .class);
if (super_class >= self.constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = self.constant_pool[super_class];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
if (self.access_flags.contains(.interface)) { if (self.access_flags.contains(.interface)) {
const super_class_name = (try cp_info.?.class.name(self.constant_pool)).utf8; const super_class_name = (try super_class.class.name(self.constant_pool)).utf8;
if (!std.mem.eql(u8, super_class_name.bytes, "java/lang/Object")) return ResolveError.InvalidConstantType; if (!std.mem.eql(u8, super_class_name.bytes, "java/lang/Object")) return ResolveError.InvalidConstantType;
} else { } else {
// TODO: Assert that superclass does not have ACC_FINAL flag set. // TODO: Assert that superclass does not have ACC_FINAL flag set.
} }
return cp_info.?; return super_class;
} }
} }

397
src/Class/AttributeInfo.zig
View file

@ -44,12 +44,10 @@ pub const AttributeInfo = union(enum) {
const Self = @This(); const Self = @This();
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)!AttributeInfo { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)!AttributeInfo {
const attribute_name_index = try input.takeInt(u16, .big) - 1; const attribute_name_index = try input.takeInt(u16, .big);
if (attribute_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex; const attribute_name = try constant_pool.getTag(attribute_name_index, .utf8);
const cp_info = constant_pool[attribute_name_index]; const name = attribute_name.utf8.bytes;
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
const attribute_name = cp_info.?.utf8;
const attribute_length = try input.takeInt(u32, .big); const attribute_length = try input.takeInt(u32, .big);
@ -57,169 +55,169 @@ pub const AttributeInfo = union(enum) {
var limited_reader: std.Io.Reader.Limited = .init(input, .limited(attribute_length), &limited_buf); var limited_reader: std.Io.Reader.Limited = .init(input, .limited(attribute_length), &limited_buf);
const limited = &limited_reader.interface; const limited = &limited_reader.interface;
if (std.mem.eql(u8, attribute_name.bytes, "ConstantValue")) { if (std.mem.eql(u8, name, "ConstantValue")) {
return .{ return .{
.predefined = .{ .predefined = .{
.constant_value = try ConstantValue.parse(limited), .constant_value = try ConstantValue.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Code")) { } else if (std.mem.eql(u8, name, "Code")) {
return .{ return .{
.predefined = .{ .predefined = .{
.code = try Code.parse(limited, constant_pool, allocator), .code = try Code.parse(limited, constant_pool, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "StackMapTable")) { } else if (std.mem.eql(u8, name, "StackMapTable")) {
return .{ return .{
.predefined = .{ .predefined = .{
.stack_map_table = try StackMapTable.parse(limited, allocator), .stack_map_table = try StackMapTable.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Exceptions")) { } else if (std.mem.eql(u8, name, "Exceptions")) {
return .{ return .{
.predefined = .{ .predefined = .{
.exceptions = try Exceptions.parse(limited, allocator), .exceptions = try Exceptions.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "InnerClasses")) { } else if (std.mem.eql(u8, name, "InnerClasses")) {
return .{ return .{
.predefined = .{ .predefined = .{
.inner_classes = try InnerClasses.parse(limited, allocator), .inner_classes = try InnerClasses.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "EnclosingMethod")) { } else if (std.mem.eql(u8, name, "EnclosingMethod")) {
return .{ return .{
.predefined = .{ .predefined = .{
.enclosing_method = try EnclosingMethod.parse(limited), .enclosing_method = try EnclosingMethod.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Synthetic")) { } else if (std.mem.eql(u8, name, "Synthetic")) {
return .{ return .{
.predefined = .{ .predefined = .{
.synthetic = .{}, .synthetic = .{},
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Signature")) { } else if (std.mem.eql(u8, name, "Signature")) {
return .{ return .{
.predefined = .{ .predefined = .{
.signature = try Signature.parse(limited), .signature = try Signature.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "SourceFile")) { } else if (std.mem.eql(u8, name, "SourceFile")) {
return .{ return .{
.predefined = .{ .predefined = .{
.source_file = try SourceFile.parse(limited), .source_file = try SourceFile.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "SourceDebugExtension")) { } else if (std.mem.eql(u8, name, "SourceDebugExtension")) {
return .{ return .{
.predefined = .{ .predefined = .{
.source_debug_extension = try SourceDebugExtension.parse(limited, attribute_length, allocator), .source_debug_extension = try SourceDebugExtension.parse(limited, attribute_length, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "LineNumberTable")) { } else if (std.mem.eql(u8, name, "LineNumberTable")) {
return .{ return .{
.predefined = .{ .predefined = .{
.line_number_table = try LineNumberTable.parse(limited, allocator), .line_number_table = try LineNumberTable.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "LocalVariableTable")) { } else if (std.mem.eql(u8, name, "LocalVariableTable")) {
return .{ return .{
.predefined = .{ .predefined = .{
.local_variable_table = try LocalVariableTable.parse(limited, allocator), .local_variable_table = try LocalVariableTable.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "LocalVariableTypeTable")) { } else if (std.mem.eql(u8, name, "LocalVariableTypeTable")) {
return .{ return .{
.predefined = .{ .predefined = .{
.local_variable_type_table = try LocalVariableTypeTable.parse(limited, allocator), .local_variable_type_table = try LocalVariableTypeTable.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Deprecated")) { } else if (std.mem.eql(u8, name, "Deprecated")) {
return .{ return .{
.predefined = .{ .predefined = .{
.deprecated = .{}, .deprecated = .{},
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "RuntimeVisibleAnnotations")) { } else if (std.mem.eql(u8, name, "RuntimeVisibleAnnotations")) {
return .{ return .{
.predefined = .{ .predefined = .{
.runtime_visible_annotations = try RuntimeVisibleAnnotations.parse(limited, allocator), .runtime_visible_annotations = try RuntimeVisibleAnnotations.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "RuntimeInvisibleAnnotations")) { } else if (std.mem.eql(u8, name, "RuntimeInvisibleAnnotations")) {
return .{ return .{
.predefined = .{ .predefined = .{
.runtime_invisible_annotations = try RuntimeInvisibleAnnotations.parse(limited, allocator), .runtime_invisible_annotations = try RuntimeInvisibleAnnotations.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "RuntimeVisibleParameterAnnotations")) { } else if (std.mem.eql(u8, name, "RuntimeVisibleParameterAnnotations")) {
return .{ return .{
.predefined = .{ .predefined = .{
.runtime_visible_parameter_annotations = try RuntimeVisibleParameterAnnotations.parse(limited, allocator), .runtime_visible_parameter_annotations = try RuntimeVisibleParameterAnnotations.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "RuntimeInvisibleParameterAnnotations")) { } else if (std.mem.eql(u8, name, "RuntimeInvisibleParameterAnnotations")) {
return .{ return .{
.predefined = .{ .predefined = .{
.runtime_invisible_parameter_annotations = try RuntimeInvisibleParameterAnnotations.parse(limited, allocator), .runtime_invisible_parameter_annotations = try RuntimeInvisibleParameterAnnotations.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "AnnotationDefault")) { } else if (std.mem.eql(u8, name, "AnnotationDefault")) {
return .{ return .{
.predefined = .{ .predefined = .{
.annotation_default = try AnnotationDefault.parse(limited, allocator), .annotation_default = try AnnotationDefault.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "BootstrapMethods")) { } else if (std.mem.eql(u8, name, "BootstrapMethods")) {
return .{ return .{
.predefined = .{ .predefined = .{
.bootstrap_methods = try BootstrapMethods.parse(limited, allocator), .bootstrap_methods = try BootstrapMethods.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "MethodParameters")) { } else if (std.mem.eql(u8, name, "MethodParameters")) {
return .{ return .{
.predefined = .{ .predefined = .{
.method_parameters = try MethodParameters.parse(limited, allocator), .method_parameters = try MethodParameters.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Module")) { } else if (std.mem.eql(u8, name, "Module")) {
return .{ return .{
.predefined = .{ .predefined = .{
.module = try Module.parse(limited, allocator), .module = try Module.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "ModulePackages")) { } else if (std.mem.eql(u8, name, "ModulePackages")) {
return .{ return .{
.predefined = .{ .predefined = .{
.module_packages = try ModulePackages.parse(limited, allocator), .module_packages = try ModulePackages.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "ModuleMainClass")) { } else if (std.mem.eql(u8, name, "ModuleMainClass")) {
return .{ return .{
.predefined = .{ .predefined = .{
.module_main_class = try ModuleMainClass.parse(limited), .module_main_class = try ModuleMainClass.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "NestHost")) { } else if (std.mem.eql(u8, name, "NestHost")) {
return .{ return .{
.predefined = .{ .predefined = .{
.nest_host = try NestHost.parse(limited), .nest_host = try NestHost.parse(limited),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "NestMembers")) { } else if (std.mem.eql(u8, name, "NestMembers")) {
return .{ return .{
.predefined = .{ .predefined = .{
.nest_members = try NestMembers.parse(limited, allocator), .nest_members = try NestMembers.parse(limited, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "Record")) { } else if (std.mem.eql(u8, name, "Record")) {
return .{ return .{
.predefined = .{ .predefined = .{
.record = try Record.parse(limited, constant_pool, allocator), .record = try Record.parse(limited, constant_pool, allocator),
}, },
}; };
} else if (std.mem.eql(u8, attribute_name.bytes, "PermittedSubclasses")) { } else if (std.mem.eql(u8, name, "PermittedSubclasses")) {
return .{ return .{
.predefined = .{ .predefined = .{
.permitted_subclasses = try PermittedSubclasses.parse(limited, allocator), .permitted_subclasses = try PermittedSubclasses.parse(limited, allocator),
@ -266,7 +264,7 @@ pub const AttributeInfo = union(enum) {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
switch (self.*) { switch (self.*) {
.new => |new| { .new => |new| {
@ -343,15 +341,11 @@ pub const AttributeInfo = union(enum) {
exception_indent += 1; exception_indent += 1;
defer exception_indent -= 1; defer exception_indent -= 1;
const index = exception_index - 1; const info = constant_pool.getTag(exception_index, .class) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
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 cp_info.?.indentedFormat(w, depth, exception_indent + 1, constant_pool); try info.indentedFormat(w, depth, exception_indent + 1, constant_pool);
} }
}, },
.inner_classes => |attr| { .inner_classes => |attr| {
@ -482,15 +476,11 @@ pub const AttributeInfo = union(enum) {
package_indent += 1; package_indent += 1;
defer package_indent -= 1; defer package_indent -= 1;
const index = package_index - 1; const info = constant_pool.getTag(package_index, .package) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .package) return error.WriteFailed;
try w.splatByteAll(' ', depth * package_indent); try w.splatByteAll(' ', depth * package_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, package_indent + 1, constant_pool); try info.indentedFormat(w, depth, package_indent + 1, constant_pool);
} }
}, },
.module_main_class => |attr| { .module_main_class => |attr| {
@ -513,15 +503,11 @@ pub const AttributeInfo = union(enum) {
class_indent += 1; class_indent += 1;
defer class_indent -= 1; defer class_indent -= 1;
const index = class_index - 1; const info = constant_pool.getTag(class_index, .class) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
try w.splatByteAll(' ', depth * class_indent); try w.splatByteAll(' ', depth * class_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, class_indent + 1, constant_pool); try info.indentedFormat(w, depth, class_indent + 1, constant_pool);
} }
}, },
.record => |attr| { .record => |attr| {
@ -545,15 +531,11 @@ pub const AttributeInfo = union(enum) {
class_indent += 1; class_indent += 1;
defer class_indent -= 1; defer class_indent -= 1;
const index = class_index - 1; const info = constant_pool.getTag(class_index, .class) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
try w.splatByteAll(' ', depth * class_indent); try w.splatByteAll(' ', depth * class_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, class_indent + 1, constant_pool); try info.indentedFormat(w, depth, class_indent + 1, constant_pool);
} }
}, },
else => {}, else => {},
@ -580,13 +562,8 @@ pub const NewAttribute = struct {
allocator.free(self.info); allocator.free(self.info);
} }
pub fn attributeName(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn attributeName(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const attribute_name_index = self.attribute_name_index - 1; return constant_pool.getTag(self.attribute_name_index, .utf8);
if (attribute_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[attribute_name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -601,13 +578,8 @@ pub const ConstantValue = struct {
}; };
} }
pub fn constantValue(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn constantValue(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const constant_value_index = self.constant_value_index - 1; return constant_pool.get(self.constant_value_index);
if (constant_value_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[constant_value_index];
if (cp_info == null) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -631,7 +603,7 @@ pub const Code = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("start_pc: {d}\n", .{ self.start_pc }); try w.print("start_pc: {d}\n", .{ self.start_pc });
@ -650,17 +622,12 @@ pub const Code = struct {
} }
} }
pub fn catchType(self: *const ExceptionHandler, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn catchType(self: *const ExceptionHandler, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.catch_type == 0) return null; return constant_pool.getTagOptional(self.catch_type, .class);
const catch_type = self.catch_type - 1;
if (catch_type >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[catch_type];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)!Self { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)!Self {
const max_stack = try input.takeInt(u16, .big); const max_stack = try input.takeInt(u16, .big);
const max_locals = try input.takeInt(u16, .big); const max_locals = try input.takeInt(u16, .big);
@ -947,7 +914,7 @@ pub const InnerClasses = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("flags: {f}\n", .{ self.inner_class_access_flags }); try w.print("flags: {f}\n", .{ self.inner_class_access_flags });
@ -972,32 +939,16 @@ pub const InnerClasses = struct {
} }
} }
pub fn innerClass(self: *const InnerClass, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn innerClass(self: *const InnerClass, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const inner_class_info_index = self.inner_class_info_index - 1; return constant_pool.getTag(self.inner_class_info_index, .class);
if (inner_class_info_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[inner_class_info_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn outerClass(self: *const InnerClass, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn outerClass(self: *const InnerClass, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.outer_class_info_index == 0) return null; return constant_pool.getTagOptional(self.outer_class_info_index, .class);
const outer_class_info_index = self.outer_class_info_index - 1;
if (outer_class_info_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[outer_class_info_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn innerName(self: *const InnerClass, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn innerName(self: *const InnerClass, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.inner_name_index == 0) return null; return constant_pool.getTagOptional(self.inner_name_index, .utf8);
const inner_name_index = self.inner_name_index - 1;
if (inner_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[inner_name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1037,21 +988,12 @@ pub const EnclosingMethod = struct {
}; };
} }
pub fn class(self: *const EnclosingMethod, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn class(self: *const EnclosingMethod, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const class_index = self.class_index - 1; return constant_pool.getTag(self.class_index, .class);
if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[class_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn method(self: *const EnclosingMethod, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn method(self: *const EnclosingMethod, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.method_index == 0) return null; return constant_pool.getTagOptional(self.method_index, .name_and_type);
const method_index = self.method_index - 1;
if (method_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[method_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1068,12 +1010,8 @@ pub const Signature = struct {
}; };
} }
pub fn signature(self: *const Signature, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn signature(self: *const Signature, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const signature_index = self.signature_index - 1; return constant_pool.getTag(self.signature_index, .utf8);
if (signature_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[signature_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1088,12 +1026,8 @@ pub const SourceFile = struct {
}; };
} }
pub fn sourceFile(self: *const SourceFile, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn sourceFile(self: *const SourceFile, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const source_file_index = self.source_file_index - 1; return constant_pool.getTag(self.source_file_index, .utf8);
if (source_file_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[source_file_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1174,7 +1108,7 @@ pub const LocalVariableTable = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("start_pc: {d}\n", .{ self.start_pc }); try w.print("start_pc: {d}\n", .{ self.start_pc });
@ -1193,20 +1127,12 @@ pub const LocalVariableTable = struct {
try descriptor_.indentedFormat(w, depth, indent + 1, constant_pool); try descriptor_.indentedFormat(w, depth, indent + 1, constant_pool);
} }
pub fn name(self: *const LocalVariable, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const LocalVariable, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn descriptor(self: *const LocalVariable, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn descriptor(self: *const LocalVariable, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const descriptor_index = self.descriptor_index - 1; return constant_pool.getTag(self.descriptor_index, .utf8);
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1251,7 +1177,7 @@ pub const LocalVariableTypeTable = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("start_pc: {d}\n", .{ self.start_pc }); try w.print("start_pc: {d}\n", .{ self.start_pc });
@ -1270,20 +1196,12 @@ pub const LocalVariableTypeTable = struct {
try signature_.indentedFormat(w, depth, indent + 1, constant_pool); try signature_.indentedFormat(w, depth, indent + 1, constant_pool);
} }
pub fn name(self: *const LocalVariableType, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const LocalVariableType, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn signature(self: *const LocalVariableType, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn signature(self: *const LocalVariableType, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const signature_index = self.signature_index - 1; return constant_pool.getTag(self.signature_index, .utf8);
if (signature_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[signature_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1623,7 +1541,7 @@ pub const BootstrapMethods = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const bootstrap_method = self.bootstrapMethod(constant_pool) catch return error.WriteFailed; const bootstrap_method = self.bootstrapMethod(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -1637,24 +1555,16 @@ pub const BootstrapMethods = struct {
bootstrap_argument_indent += 1; bootstrap_argument_indent += 1;
defer bootstrap_argument_indent -= 1; defer bootstrap_argument_indent -= 1;
const index = bootstrap_argument - 1; const info = constant_pool.getLoadable(bootstrap_argument) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or !@as(ConstantPool.Info.Tag, cp_info.?).loadable()) return error.WriteFailed;
try w.splatByteAll(' ', depth * bootstrap_argument_indent); try w.splatByteAll(' ', depth * bootstrap_argument_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, bootstrap_argument_indent + 1, constant_pool); try info.indentedFormat(w, depth, bootstrap_argument_indent + 1, constant_pool);
} }
} }
pub fn bootstrapMethod(self: *const BootstrapMethod, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn bootstrapMethod(self: *const BootstrapMethod, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const bootstrap_method_ref = self.bootstrap_method_ref - 1; return constant_pool.getTag(self.bootstrap_method_ref, .method_handle);
if (bootstrap_method_ref >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[bootstrap_method_ref];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .method_handle) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1711,7 +1621,7 @@ pub const MethodParameters = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("flags: {f}\n", .{ self.access_flags }); try w.print("flags: {f}\n", .{ self.access_flags });
@ -1722,12 +1632,8 @@ pub const MethodParameters = struct {
try name_.indentedFormat(w, depth, indent + 1, constant_pool); try name_.indentedFormat(w, depth, indent + 1, constant_pool);
} }
pub fn name(self: *const Parameter, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const Parameter, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1787,7 +1693,7 @@ pub const Module = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const requires_ = self.requires(constant_pool) catch return error.WriteFailed; const requires_ = self.requires(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -1805,21 +1711,12 @@ pub const Module = struct {
} }
} }
pub fn requires(self: *const Requires, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn requires(self: *const Requires, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const requires_index = self.requires_index - 1; return constant_pool.getTag(self.requires_index, .module);
if (requires_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[requires_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .module) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn requiresVersion(self: *const Requires, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn requiresVersion(self: *const Requires, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.requires_version_index == 0) return null; return constant_pool.getTagOptional(self.requires_version_index, .utf8);
const requires_version_index = self.requires_version_index - 1;
if (requires_version_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[requires_version_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1838,7 +1735,7 @@ pub const Module = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const exports_ = self.exports(constant_pool) catch return error.WriteFailed; const exports_ = self.exports(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -1855,24 +1752,16 @@ pub const Module = struct {
exports_to_indent += 1; exports_to_indent += 1;
defer exports_to_indent -= 1; defer exports_to_indent -= 1;
const index = exports_to_index - 1; const info = constant_pool.getTag(exports_to_index, .module) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .module) return error.WriteFailed;
try w.splatByteAll(' ', depth * exports_to_indent); try w.splatByteAll(' ', depth * exports_to_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, exports_to_indent + 1, constant_pool); try info.indentedFormat(w, depth, exports_to_indent + 1, constant_pool);
} }
} }
pub fn exports(self: *const Exports, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn exports(self: *const Exports, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const exports_index = self.exports_index - 1; return constant_pool.getTag(self.exports_index, .package);
if (exports_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[exports_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .package) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1891,7 +1780,7 @@ pub const Module = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const opens_ = self.opens(constant_pool) catch return error.WriteFailed; const opens_ = self.opens(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -1908,24 +1797,16 @@ pub const Module = struct {
opens_to_indent += 1; opens_to_indent += 1;
defer opens_to_indent -= 1; defer opens_to_indent -= 1;
const index = opens_to_index - 1; const info = constant_pool.getTag(opens_to_index, .module) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .module) return error.WriteFailed;
try w.splatByteAll(' ', depth * opens_to_indent); try w.splatByteAll(' ', depth * opens_to_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, opens_to_indent + 1, constant_pool); try info.indentedFormat(w, depth, opens_to_indent + 1, constant_pool);
} }
} }
pub fn opens(self: *const Opens, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn opens(self: *const Opens, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const opens_index = self.opens_index - 1; return constant_pool.getTag(self.opens_index, .package);
if (opens_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[opens_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .package) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -1938,7 +1819,7 @@ pub const Module = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const provides_ = self.provides(constant_pool) catch return error.WriteFailed; const provides_ = self.provides(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -1952,24 +1833,16 @@ pub const Module = struct {
provides_with_indent += 1; provides_with_indent += 1;
defer provides_with_indent -= 1; defer provides_with_indent -= 1;
const index = provides_with_index - 1; const info = constant_pool.getTag(provides_with_index, .class) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
try w.splatByteAll(' ', depth * provides_with_indent); try w.splatByteAll(' ', depth * provides_with_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, provides_with_indent + 1, constant_pool); try info.indentedFormat(w, depth, provides_with_indent + 1, constant_pool);
} }
} }
pub fn provides(self: *const Provides, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn provides(self: *const Provides, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const provides_index = self.provides_index - 1; return constant_pool.getTag(self.provides_index, .class);
if (provides_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[provides_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -2088,7 +1961,7 @@ pub const Module = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const module_name = self.moduleName(constant_pool) catch return error.WriteFailed; const module_name = self.moduleName(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -2148,15 +2021,11 @@ pub const Module = struct {
uses_indent += 1; uses_indent += 1;
defer uses_indent -= 1; defer uses_indent -= 1;
const index = uses_index - 1; const info = constant_pool.getTag(uses_index, .class) catch return error.WriteFailed;
if (index >= constant_pool.len) return error.WriteFailed;
const cp_info = constant_pool[index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return error.WriteFailed;
try w.splatByteAll(' ', depth * uses_indent); try w.splatByteAll(' ', depth * uses_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try cp_info.?.indentedFormat(w, depth, uses_indent + 1, constant_pool); try info.indentedFormat(w, depth, uses_indent + 1, constant_pool);
} }
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -2172,21 +2041,12 @@ pub const Module = struct {
} }
} }
pub fn moduleName(self: *const Module, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn moduleName(self: *const Module, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const module_name_index = self.module_name_index - 1; return constant_pool.getTag(self.module_name_index, .utf8);
if (module_name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[module_name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn moduleVersion(self: *const Module, constant_pool: []const ?ConstantPool.Info) ResolveError!?ConstantPool.Info { pub fn moduleVersion(self: *const Module, constant_pool: ConstantPool) ResolveError!?ConstantPool.Info {
if (self.module_version_index == 0) return null; return constant_pool.getTagOptional(self.module_version_index, .utf8);
const module_version_index = self.module_version_index - 1;
if (module_version_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[module_version_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -2224,12 +2084,8 @@ pub const ModuleMainClass = struct {
}; };
} }
pub fn mainClass(self: *const ModuleMainClass, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn mainClass(self: *const ModuleMainClass, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const main_class_index = self.main_class_index - 1; return constant_pool.getTag(self.main_class_index, .class);
if (main_class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[main_class_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -2244,12 +2100,8 @@ pub const NestHost = struct {
}; };
} }
pub fn hostClass(self: *const NestHost, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn hostClass(self: *const NestHost, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const host_class_index = self.host_class_index - 1; return constant_pool.getTag(self.host_class_index, .class);
if (host_class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[host_class_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -2285,7 +2137,7 @@ pub const Record = struct {
descriptor_index: u16, descriptor_index: u16,
attributes: []AttributeInfo, attributes: []AttributeInfo,
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)!RecordComponentInfo { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)!RecordComponentInfo {
const name_index = try input.takeInt(u16, .big); const name_index = try input.takeInt(u16, .big);
const descriptor_index = try input.takeInt(u16, .big); const descriptor_index = try input.takeInt(u16, .big);
@ -2315,7 +2167,7 @@ pub const Record = struct {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
const name_ = self.name(constant_pool) catch return error.WriteFailed; const name_ = self.name(constant_pool) catch return error.WriteFailed;
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
@ -2336,29 +2188,20 @@ pub const Record = struct {
try w.splatByteAll(' ', depth * attr_indent); try w.splatByteAll(' ', depth * attr_indent);
try w.print("{d}:\n", .{ i }); try w.print("{d}:\n", .{ i });
try attr.indentedFormat(w, depth, attr_indent + 1, constant_pool); try attr.indentedFormat(w, depth, attr_indent + 1, constant_pool);
} }
} }
pub fn name(self: *const RecordComponentInfo, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const RecordComponentInfo, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn descriptor(self: *const RecordComponentInfo, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn descriptor(self: *const RecordComponentInfo, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const descriptor_index = self.descriptor_index - 1; return constant_pool.getTag(self.descriptor_index, .utf8);
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) (ParseError || ResolveError)!Self { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) (ParseError || ResolveError)!Self {
const components_count = try input.takeInt(u16, .big); const components_count = try input.takeInt(u16, .big);
const components = try allocator.alloc(RecordComponentInfo, components_count); const components = try allocator.alloc(RecordComponentInfo, components_count);
for (components) |*component| { for (components) |*component| {

236
src/Class/ConstantPool.zig
View file

@ -5,6 +5,10 @@ const AttributeInfo = Class.AttributeInfo;
const ParseError = Class.ParseError; const ParseError = Class.ParseError;
const ResolveError = Class.ResolveError; const ResolveError = Class.ResolveError;
constant_pool: []?Info,
const Self = @This();
pub const Info = union(Info.Tag) { pub const Info = union(Info.Tag) {
class: Info.Class, class: Info.Class,
field_ref: FieldRef, field_ref: FieldRef,
@ -54,14 +58,8 @@ pub const Info = union(Info.Tag) {
pub const Class = struct { pub const Class = struct {
name_index: u16, name_index: u16,
const Self = @This(); pub fn name(self: *const Info.Class, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_index, .utf8);
pub fn name(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_index = self.name_index - 1;
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -69,22 +67,12 @@ pub const Info = union(Info.Tag) {
class_index: u16, class_index: u16,
name_and_type_index: u16, name_and_type_index: u16,
const Self = @This(); pub fn class(self: *const FieldRef, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.class_index, .class);
pub fn class(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const class_index = self.class_index - 1;
if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[class_index];
if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn nameAndType(self: *const Self, constant_pool: []const ?Info) ResolveError!Info { pub fn nameAndType(self: *const FieldRef, constant_pool: Self) ResolveError!Info {
const name_and_type_index = self.name_and_type_index - 1; return constant_pool.getTag(self.name_and_type_index, .name_and_type);
if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_and_type_index];
if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -92,22 +80,12 @@ pub const Info = union(Info.Tag) {
class_index: u16, class_index: u16,
name_and_type_index: u16, name_and_type_index: u16,
const Self = @This(); pub fn class(self: *const MethodRef, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.class_index, .class);
pub fn class(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const class_index = self.class_index - 1;
if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[class_index];
if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn nameAndType(self: *const Self, constant_pool: []const ?Info) ResolveError!Info { pub fn nameAndType(self: *const MethodRef, constant_pool: Self) ResolveError!Info {
const name_and_type_index = self.name_and_type_index - 1; return constant_pool.getTag(self.name_and_type_index, .name_and_type);
if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_and_type_index];
if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -115,36 +93,20 @@ pub const Info = union(Info.Tag) {
class_index: u16, class_index: u16,
name_and_type_index: u16, name_and_type_index: u16,
const Self = @This(); pub fn class(self: *const InterfaceMethodRef, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.class_index, .class);
pub fn class(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const class_index = self.class_index - 1;
if (class_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[class_index];
if (cp_info == null or @as(Tag, cp_info.?) != .class) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn nameAndType(self: *const Self, constant_pool: []const ?Info) ResolveError!Info { pub fn nameAndType(self: *const InterfaceMethodRef, constant_pool: Self) ResolveError!Info {
const name_and_type_index = self.name_and_type_index - 1; return constant_pool.getTag(self.name_and_type_index, .name_and_type);
if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_and_type_index];
if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
pub const String = struct { pub const String = struct {
string_index: u16, string_index: u16,
const Self = @This(); pub fn string(self: *const String, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.string_index, .utf8);
pub fn string(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const string_index = self.string_index - 1;
if (string_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[string_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -170,22 +132,12 @@ pub const Info = union(Info.Tag) {
name_index: u16, name_index: u16,
descriptor_index: u16, descriptor_index: u16,
const Self = @This(); pub fn name(self: *const NameAndType, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_index, .utf8);
pub fn name(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_index = self.name_index - 1;
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn descriptor(self: *const Self, constant_pool: []const ?Info) ResolveError!Info { pub fn descriptor(self: *const NameAndType, constant_pool: Self) ResolveError!Info {
const descriptor_index = self.descriptor_index - 1; return constant_pool.getTag(self.descriptor_index, .utf8);
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -197,8 +149,6 @@ pub const Info = union(Info.Tag) {
reference_kind: Kind, reference_kind: Kind,
reference_index: u16, reference_index: u16,
const Self = @This();
pub const Kind = enum(u8) { pub const Kind = enum(u8) {
get_field = 1, get_field = 1,
get_static = 2, get_static = 2,
@ -211,22 +161,20 @@ pub const Info = union(Info.Tag) {
invoke_interface = 9, invoke_interface = 9,
}; };
pub fn reference(self: *const Self, constant_pool: []const ?Info) ResolveError!Info { pub fn reference(self: *const MethodHandle, constant_pool: Self) ResolveError!Info {
const reference_index = self.reference_index - 1; const info = try constant_pool.get(self.reference_index);
if (reference_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[reference_index];
return switch (self.reference_kind) { return switch (self.reference_kind) {
.get_field, .get_static, .put_field, .put_static => blk: { .get_field, .get_static, .put_field, .put_static => blk: {
if (cp_info == null or @as(Tag, cp_info.?) != .field_ref) break :blk ResolveError.InvalidConstantType; if (@as(Tag, info) != .field_ref) break :blk ResolveError.InvalidConstantType;
break :blk cp_info.?; break :blk info;
}, },
.invoke_virtual, .invoke_static, .invoke_special, .new_invoke_special => blk: { .invoke_virtual, .invoke_static, .invoke_special, .new_invoke_special => blk: {
if (cp_info == null or @as(Tag, cp_info.?) != .method_ref) break :blk ResolveError.InvalidConstantType; if (@as(Tag, info) != .method_ref) break :blk ResolveError.InvalidConstantType;
break :blk cp_info.?; break :blk info;
}, },
.invoke_interface => blk: { .invoke_interface => blk: {
if (cp_info == null or @as(Tag, cp_info.?) != .interface_method_ref) break :blk ResolveError.InvalidConstantType; if (@as(Tag, info) != .interface_method_ref) break :blk ResolveError.InvalidConstantType;
break :blk cp_info.?; break :blk info;
}, },
}; };
} }
@ -235,14 +183,8 @@ pub const Info = union(Info.Tag) {
pub const MethodType = struct { pub const MethodType = struct {
descriptor_index: u16, descriptor_index: u16,
const Self = @This(); pub fn descriptor(self: *const MethodType, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.descriptor_index, .utf8);
pub fn descriptor(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const descriptor_index = self.descriptor_index - 1;
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -250,14 +192,8 @@ pub const Info = union(Info.Tag) {
bootstrap_method_attr_index: u16, bootstrap_method_attr_index: u16,
name_and_type_index: u16, name_and_type_index: u16,
const Self = @This(); pub fn nameAndType(self: *const Dynamic, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_and_type_index, .name_and_type);
pub fn nameAndType(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_and_type_index = self.name_and_type_index - 1;
if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_and_type_index];
if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -265,42 +201,24 @@ pub const Info = union(Info.Tag) {
bootstrap_method_attr_index: u16, bootstrap_method_attr_index: u16,
name_and_type_index: u16, name_and_type_index: u16,
const Self = @This(); pub fn nameAndType(self: *const InvokeDynamic, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_and_type_index, .name_and_type);
pub fn nameAndType(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_and_type_index = self.name_and_type_index - 1;
if (name_and_type_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_and_type_index];
if (cp_info == null or @as(Tag, cp_info.?) != .name_and_type) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
pub const Module = struct { pub const Module = struct {
name_index: u16, name_index: u16,
const Self = @This(); pub fn name(self: *const Module, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_index, .utf8);
pub fn name(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_index = self.name_index - 1;
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
pub const Package = struct { pub const Package = struct {
name_index: u16, name_index: u16,
const Self = @This(); pub fn name(self: *const Package, constant_pool: Self) ResolveError!Info {
return constant_pool.getTag(self.name_index, .utf8);
pub fn name(self: *const Self, constant_pool: []const ?Info) ResolveError!Info {
const name_index = self.name_index - 1;
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
}; };
@ -450,7 +368,7 @@ pub const Info = union(Info.Tag) {
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?Info, constant_pool: Self,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("constant_value_type: {s}\n", .{ @tagName(self.*) }); try w.print("constant_value_type: {s}\n", .{ @tagName(self.*) });
@ -579,3 +497,71 @@ pub const Info = union(Info.Tag) {
} }
} }
}; };
pub fn parse(input: *std.Io.Reader, allocator: std.mem.Allocator) ParseError!Self {
const constant_pool_size = try input.takeInt(u16, .big);
const constant_pool = try allocator.alloc(?Info, constant_pool_size - 1);
errdefer allocator.free(constant_pool);
var i: usize = 0;
while (i < constant_pool_size - 1) {
defer i += 1;
const info: Info = try .parse(input, allocator);
constant_pool[i] = info;
switch (info) {
.long, .double => {
i += 1;
constant_pool[i] = null;
},
else => {},
}
}
return .{
.constant_pool = constant_pool,
};
}
pub fn deinit(self: *Self, allocator: std.mem.Allocator) void {
for (self.constant_pool) |*info| {
if (info.*) |*c| c.deinit(allocator);
}
allocator.free(self.constant_pool);
}
pub fn get(self: *const Self, index: u16) ResolveError!Info {
const actual_index = index - 1;
if (actual_index >= self.constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const info = self.constant_pool[actual_index];
if (info == null) return ResolveError.InvalidConstantType;
return info.?;
}
pub fn getOptional(self: *const Self, index: u16) ResolveError!?Info {
if (index == 0) return null;
return self.get(index);
}
pub fn getTag(self: *const Self, index: u16, expected_tag: Info.Tag) ResolveError!Info {
const info = try self.get(index);
if (@as(Info.Tag, info) != expected_tag) return ResolveError.InvalidConstantType;
return info;
}
pub fn getTagOptional(self: *const Self, index: u16, expected_tag: Info.Tag) ResolveError!?Info {
if (index == 0) return null;
return try self.getTag(index, expected_tag);
}
pub fn getLoadable(self: *const Self, index: u16) ResolveError!Info {
const info = try self.get(index);
if (!@as(Info.Tag, info).loadable()) return ResolveError.InvalidConstantType;
return info;
}
pub fn getLoadableOptional(self: *const Self, index: u16) ResolveError!?Info {
if (index == 0) return null;
return self.getLoadable(index);
}

20
src/Class/FieldInfo.zig
View file

@ -26,7 +26,7 @@ pub const FieldAccessFlags = EnumFlags(enum(u16) {
@"enum" = 0x4000, @"enum" = 0x4000,
}); });
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) !Self { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) !Self {
const access_flags: FieldAccessFlags = .{ .mask = try input.takeInt(u16, .big) }; const access_flags: FieldAccessFlags = .{ .mask = try input.takeInt(u16, .big) };
const name_index = try input.takeInt(u16, .big); const name_index = try input.takeInt(u16, .big);
const descriptor_index = try input.takeInt(u16, .big); const descriptor_index = try input.takeInt(u16, .big);
@ -51,7 +51,7 @@ pub fn indentedFormat(
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("flags: {f}\n", .{ self.access_flags }); try w.print("flags: {f}\n", .{ self.access_flags });
@ -80,19 +80,11 @@ pub fn indentedFormat(
} }
} }
pub fn name(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn descriptor(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn descriptor(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const descriptor_index = self.descriptor_index - 1; return constant_pool.getTag(self.descriptor_index, .utf8);
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }

21
src/Class/MethodInfo.zig
View file

@ -29,7 +29,7 @@ pub const MethodAccessFlags = EnumFlags(enum(u16) {
synthetic = 0x1000, synthetic = 0x1000,
}); });
pub fn parse(input: *std.Io.Reader, constant_pool: []const ?ConstantPool.Info, allocator: std.mem.Allocator) !Self { pub fn parse(input: *std.Io.Reader, constant_pool: ConstantPool, allocator: std.mem.Allocator) !Self {
const access_flags: MethodAccessFlags = .{ .mask = try input.takeInt(u16, .big) }; const access_flags: MethodAccessFlags = .{ .mask = try input.takeInt(u16, .big) };
const name_index = try input.takeInt(u16, .big); const name_index = try input.takeInt(u16, .big);
const descriptor_index = try input.takeInt(u16, .big); const descriptor_index = try input.takeInt(u16, .big);
@ -54,7 +54,7 @@ pub fn indentedFormat(
w: *std.Io.Writer, w: *std.Io.Writer,
depth: usize, depth: usize,
indent: u8, indent: u8,
constant_pool: []const ?ConstantPool.Info, constant_pool: ConstantPool,
) std.Io.Writer.Error!void { ) std.Io.Writer.Error!void {
try w.splatByteAll(' ', depth * indent); try w.splatByteAll(' ', depth * indent);
try w.print("flags: {f}\n", .{ self.access_flags }); try w.print("flags: {f}\n", .{ self.access_flags });
@ -83,19 +83,10 @@ pub fn indentedFormat(
} }
} }
pub fn name(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn name(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const name_index = self.name_index - 1; return constant_pool.getTag(self.name_index, .utf8);
if (name_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[name_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }
pub fn descriptor(self: *const Self, constant_pool: []const ?ConstantPool.Info) ResolveError!ConstantPool.Info { pub fn descriptor(self: *const Self, constant_pool: ConstantPool) ResolveError!ConstantPool.Info {
const descriptor_index = self.descriptor_index - 1; return constant_pool.getTag(self.descriptor_index, .utf8);
if (descriptor_index >= constant_pool.len) return ResolveError.InvalidConstantPoolIndex;
const cp_info = constant_pool[descriptor_index];
if (cp_info == null or @as(ConstantPool.Info.Tag, cp_info.?) != .utf8) return ResolveError.InvalidConstantType;
return cp_info.?;
} }

10
src/main.zig
View file

@ -52,16 +52,6 @@ pub fn main(init: std.process.Init) !void {
}; };
defer class.deinit(); defer class.deinit();
if (@import("builtin").mode == .Debug) {
for (class.constant_pool, 1..) |cp_info, i| {
if (cp_info) |info| {
std.debug.print("#{d} = {s}\t{f}\n", .{ i, @tagName(info), info });
} else {
std.debug.print("#{d} = null\n", .{ i });
}
}
}
try stdout.print("{f}", .{ class }); try stdout.print("{f}", .{ class });
try stdout.flush(); try stdout.flush();