{{ message }}
Repository navigation
Expand file tree
/
Copy pathClassFile.zig
More file actions
250 lines (211 loc) · 11.7 KB
/
Copy pathClassFile.zig
File metadata and controls
250 lines (211 loc) · 11.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
//! A Java ClassFile parser matching the spec detailed here: https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.1
//! It's important to note that "class" file is misleading as classes as well as interfaces and enums are described here
// NOTE: The JDK docs refer to numeric types as u1, u2, etc. - these are in BYTES, not BITS (u1 = u8, u2 = u16, etc.)
const std = @import("std");
const utils = @import("utils.zig");
const attributes = @import("attributes.zig");
const FieldInfo = @import("FieldInfo.zig");
const MethodInfo = @import("MethodInfo.zig");
const ConstantPool = @import("ConstantPool.zig");
const ClassFile = @This();
/// Denotes access permissions to and properties of this class or interface
pub const AccessFlags = struct {
/// Declared public; may be accessed from outside its package
public: bool = false,
/// Declared final; no subclasses allowed.
final: bool = false,
/// Treat superclass methods specially when invoked by the invokespecial instruction
super: bool = false,
/// Is an interface, not a class
interface: bool = false,
/// Declared abstract; must not be instantiated
abstract: bool = false,
/// Declared synthetic; not present in the source code
synthetic: bool = false,
/// Declared as an annotation interface
annotation: bool = false,
/// Declared as an enum class
enum_class: bool = false,
/// Is a module, not a class or interface
module: bool = false,
};
// To see what the major and minor versions actually correspond to, see https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.1-200-B.2
minor_version: u16,
major_version: u16,
/// The constant_pool is a table of structures ([§4.4](https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.4)) representing various string constants, class and interface names, field names, and other constants that are referred to within the ClassFile structure and its substructures
///
/// The constant_pool table is indexed from 1 to ConstantPoolcount - 1
constant_pool: *ConstantPool,
/// The value of the access_flags item is a mask of flags used to denote access permissions to and properties of this class or interface. The interpretation of each flag, when set, is specified in [Table 4.1-B](https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.1-200-E.1)
access_flags: AccessFlags,
/// The value of the this_class item must be a valid index into the constant_pool table and the entry at that index must be a CONSTANT_Class_info structure ([§4.4.1](https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.4.1)) representing the class or interface defined by this class file
this_class: u16,
/// For a class, the value of the super_class item either must be zero or must be a valid index into the constant_pool table. If the value of the super_class item is nonzero, the constant_pool entry at that index must be a CONSTANT_Class_info structure representing the direct superclass of the class defined by this class file. Neither the direct superclass nor any of its superclasses may have the ACC_FINAL flag set in the access_flags item of its ClassFile structure.
///
/// If the value of the super_class item is zero, then this class file must represent the class Object, the only class or interface without a direct superclass.
///
/// For an interface, the value of the super_class item must always be a valid index into the constant_pool table. The constant_pool entry at that index must be a CONSTANT_Class_info structure representing the class Object.
super_class: ?u16,
/// Each value in the interfaces array must be a valid index into the constant_pool table and the entry at each value of interfaces[i], where 0 ≤ i < interfaces_count, must be a CONSTANT_Class_info structure representing an interface that is a direct superinterface of this class or interface type, in the left-to-right order given in the source for the type
interfaces: std.ArrayList(u16),
/// Fields this class has
fields: std.ArrayList(FieldInfo),
/// Methods the class has
methods: std.ArrayList(MethodInfo),
/// Attributes the class has
attributes: std.ArrayList(attributes.AttributeInfo),
pub fn decode(allocator: std.mem.Allocator, reader: anytype) !ClassFile {
var magic = try reader.readIntBig(u32);
if (magic != 0xCAFEBABE) return error.BadMagicValue;
var minor_version = try reader.readIntBig(u16);
var major_version = try reader.readIntBig(u16);
var entry_count = (try reader.readIntBig(u16)) - 1;
var constant_pool = try ConstantPool.init(allocator, entry_count);
// try constant_pool.entries.ensureTotalCapacity(constant_pool_length);
// constant_pool.entries.items.len = z;
try constant_pool.decodeEntries(reader);
var access_flags_u = try reader.readIntBig(u16);
var access_flags = AccessFlags{
.public = utils.isPresent(u16, access_flags_u, 0x0001),
.final = utils.isPresent(u16, access_flags_u, 0x0010),
.super = utils.isPresent(u16, access_flags_u, 0x0020),
.interface = utils.isPresent(u16, access_flags_u, 0x0200),
.abstract = utils.isPresent(u16, access_flags_u, 0x0400),
.synthetic = utils.isPresent(u16, access_flags_u, 0x1000),
.annotation = utils.isPresent(u16, access_flags_u, 0x2000),
.enum_class = utils.isPresent(u16, access_flags_u, 0x4000),
.module = utils.isPresent(u16, access_flags_u, 0x8000),
};
var this_class_u = try reader.readIntBig(u16);
var this_class = this_class_u;
var super_class_u = try reader.readIntBig(u16);
var super_class = if (super_class_u == 0) null else super_class_u;
var interface_count = try reader.readIntBig(u16);
var interfaces = try std.ArrayList(u16).initCapacity(allocator, interface_count);
interfaces.items.len = interface_count;
for (interfaces.items) |*i| i.* = try reader.readIntBig(u16);
var field_count = try reader.readIntBig(u16);
var fieldss = try std.ArrayList(FieldInfo).initCapacity(allocator, field_count);
fieldss.items.len = field_count;
for (fieldss.items) |*f| f.* = try FieldInfo.decode(constant_pool, allocator, reader);
var method_count = try reader.readIntBig(u16);
var methodss = try std.ArrayList(MethodInfo).initCapacity(allocator, method_count);
methodss.items.len = method_count;
for (methodss.items) |*m| m.* = try MethodInfo.decode(constant_pool, allocator, reader);
// var attributess = try std.ArrayList(attributes.AttributeInfo).initCapacity(allocator, try reader.readIntBig(u16));
// for (attributess.items) |*a| a.* = try attributes.AttributeInfo.decode(&constant_pool, allocator, reader);
// TODO: Fix this awful, dangerous, slow hack
var attributes_length = try reader.readIntBig(u16);
var attributes_index: usize = 0;
var attributess = std.ArrayList(attributes.AttributeInfo).init(allocator);
while (attributes_index < attributes_length) : (attributes_index += 1) {
var decoded = try attributes.AttributeInfo.decode(constant_pool, allocator, reader);
if (decoded == .unknown) {
attributes_length -= 1;
continue;
}
try attributess.append(decoded);
}
return ClassFile{
.minor_version = minor_version,
.major_version = major_version,
.constant_pool = constant_pool,
.access_flags = access_flags,
.this_class = this_class,
.super_class = super_class,
.interfaces = interfaces,
.fields = fieldss,
.methods = methodss,
.attributes = attributess,
};
}
pub fn encode(self: *const ClassFile, writer: anytype) !void {
try writer.writeIntBig(u32, 0xCAFEBABE);
try writer.writeIntBig(u16, self.minor_version);
try writer.writeIntBig(u16, self.major_version);
try writer.writeIntBig(u16, @intCast(u16, self.constant_pool.entries.items.len) + 1);
var constant_pool_index: usize = 0;
while (constant_pool_index < self.constant_pool.entries.items.len) : (constant_pool_index += 1) {
var cp = self.constant_pool.entries.items[constant_pool_index];
try cp.encode(writer);
if (cp == .double or cp == .long) {
constant_pool_index += 1;
}
}
var access_flags_u: u16 = 0;
if (self.access_flags.public) utils.setPresent(u16, &access_flags_u, 0x0001);
if (self.access_flags.final) utils.setPresent(u16, &access_flags_u, 0x0010);
if (self.access_flags.super) utils.setPresent(u16, &access_flags_u, 0x0020);
if (self.access_flags.interface) utils.setPresent(u16, &access_flags_u, 0x0200);
if (self.access_flags.abstract) utils.setPresent(u16, &access_flags_u, 0x0400);
if (self.access_flags.synthetic) utils.setPresent(u16, &access_flags_u, 0x1000);
if (self.access_flags.annotation) utils.setPresent(u16, &access_flags_u, 0x2000);
if (self.access_flags.enum_class) utils.setPresent(u16, &access_flags_u, 0x4000);
if (self.access_flags.module) utils.setPresent(u16, &access_flags_u, 0x8000);
try writer.writeIntBig(u16, access_flags_u);
try writer.writeIntBig(u16, self.this_class);
try writer.writeIntBig(u16, self.super_class orelse 0);
try writer.writeIntBig(u16, @intCast(u16, self.interfaces.items.len));
for (self.interfaces.items) |i| try writer.writeIntBig(u16, i);
try writer.writeIntBig(u16, @intCast(u16, self.fields.items.len));
for (self.fields.items) |f| try f.encode(writer);
try writer.writeIntBig(u16, @intCast(u16, self.methods.items.len));
for (self.methods.items) |m| try m.encode(writer);
try writer.writeIntBig(u16, @intCast(u16, self.attributes.items.len));
for (self.attributes.items) |a| try a.encode(writer);
}
pub fn deinit(self: *ClassFile) void {
self.interfaces.deinit();
for (self.fields.items) |*fie| fie.deinit();
self.fields.deinit();
for (self.methods.items) |*met| met.deinit();
self.methods.deinit();
for (self.attributes.items) |*att| att.deinit();
self.attributes.deinit();
self.constant_pool.deinit();
}
pub const JavaSEVersion = enum { @"1.1", @"1.2", @"1.3", @"1.4", @"5.0", @"6", @"7", @"8", @"9", @"10", @"11", @"12", @"13", @"14", @"15", @"16" };
pub const GetJavaSEVersionError = error{InvalidMajorVersion};
/// Get the Java SE (or JDK for early versions) version corresponding to the ClassFile's `major_version` in accordance with [Table 4.1-A. class file format major versions](https://docs.oracle.com/javase/specs/jvms/se16/html/jvms-4.html#jvms-4.1-200-B.2)
pub fn getJavaSEVersion(self: ClassFile) GetJavaSEVersionError!JavaSEVersion {
return switch (self.major_version) {
45 => .@"1.1",
46 => .@"1.2",
47 => .@"1.3",
48 => .@"1.4",
49 => .@"5.0",
50 => .@"6",
51 => .@"7",
52 => .@"8",
53 => .@"9",
54 => .@"10",
55 => .@"11",
56 => .@"12",
57 => .@"13",
58 => .@"14",
59 => .@"15",
60 => .@"16",
else => error.InvalidMajorVersion,
};
}
test "Decode ClassFile" {
const harness = @import("../test/harness.zig");
var fbs = harness.hello.fbs();
var reader = fbs.reader();
var cf = try ClassFile.decode(std.testing.allocator, reader);
defer cf.deinit();
}
test "Encode ClassFile" {
const harness = @import("../test/harness.zig");
var fbs = harness.hello.fbs();
var reader = fbs.reader();
var joe_file = try std.fs.cwd().createFile("Hello.class", .{});
defer joe_file.close();
var cf = try ClassFile.decode(std.testing.allocator, reader);
defer cf.deinit();
try cf.encode(joe_file.writer());
var end_result: [harness.hello.data.len]u8 = undefined;
var res_fbs = std.io.fixedBufferStream(&end_result);
try cf.encode(res_fbs.writer());
try std.testing.expectEqualSlices(u8, harness.hello.data, &end_result);
}
You can’t perform that action at this time.