rjvm 0.3.0

Parse JVM class files with Rust
Documentation 
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

use crate::bytecode::attributes::Attribute;
use crate::bytecode::flags::{ClassAccessFlags, FieldAccessFlags, MethodAccessFlags};
use crate::bytecode::pool::{ConstantPool, ConstantPoolIndex};

pub mod attributes;
pub mod descriptors;
pub mod flags;
pub mod pool;
pub mod reader;

#[derive(Debug, Clone, PartialEq)]
pub enum BytecodeError {
    ConstantPoolEntryAlreadyExists,
    ConstantPoolEntryNotFound,
    UnsupportedAttributeName,
    InvalidClassFile,
    UnexpectedEndOfData,
    InvalidData,
    UnsupportedInstruction,
    InvalidDescriptor,
    UnsupportedVerificationType,
}

#[derive(Debug)]
pub struct ClassFileVersion {
    pub minor: u16,
    pub major: u16,
}

#[derive(Debug)]
pub struct ClassFile {
    pub magic_number: u32,
    pub version: ClassFileVersion,
    pub constant_pool_count: u16,
    pub constant_pool: ConstantPool,
    pub access_flags: ClassAccessFlags,
    pub this_class: ConstantPoolIndex,
    pub super_class: ConstantPoolIndex,
    pub interfaces_count: u16,
    pub interfaces: Vec<Interface>,
    pub fields_count: u16,
    pub fields: Vec<Field>,
    pub methods_count: u16,
    pub methods: Vec<Method>,
    pub attributes_count: u16,
    pub attributes: Vec<Attribute>,
}

#[derive(Debug)]
pub struct Field {
    pub name: String,
    pub descriptor: Descriptor,
    pub access_flags: FieldAccessFlags,
    pub attributes: Vec<Attribute>,
}

#[derive(Debug)]
pub struct Method {
    pub access_flags: MethodAccessFlags,
    pub name: String,
    pub descriptor: Vec<Descriptor>,
    pub attributes: Vec<Attribute>,
}

#[derive(Debug)]
pub struct Interface {
    pub name_index: ConstantPoolIndex,
}

#[derive(Debug, Clone, PartialEq)]
pub enum DescriptorKind {
    Parameter,
    Return,
    Type,
}

#[derive(Debug, Clone, PartialEq)]
pub struct Descriptor {
    pub kind: DescriptorKind,
    pub ty: FieldType,
}

impl std::fmt::Display for Descriptor {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.ty)
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum FieldType {
    Base(BaseType),
    Object(String),
    Array(Box<FieldType>),
}

impl std::fmt::Display for FieldType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            FieldType::Base(ty) => write!(f, "{}", ty),
            FieldType::Object(ty) => write!(f, "{}", ty),
            FieldType::Array(ty) => write!(f, "[{}]", ty),
        }
    }
}

#[derive(Debug, Clone, PartialEq)]
pub enum BaseType {
    Byte,
    Char,
    Double,
    Float,
    Int,
    Long,
    Short,
    Boolean,
    Void,
}

impl std::fmt::Display for BaseType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            BaseType::Byte => write!(f, "byte"),
            BaseType::Char => write!(f, "char"),
            BaseType::Double => write!(f, "double"),
            BaseType::Float => write!(f, "float"),
            BaseType::Int => write!(f, "int"),
            BaseType::Long => write!(f, "long"),
            BaseType::Short => write!(f, "short"),
            BaseType::Boolean => write!(f, "boolean"),
            BaseType::Void => write!(f, "void"),
        }
    }
}