javabc 0.1.2

Java bytecode manipulation library
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

use {AccessFlags, Type};

#[derive(Clone, Debug)]
pub struct Method
{
    pub access_flags: AccessFlags,
    pub name: String,
    pub signature: MethodSignature,
    pub bitcode: Vec<u8>,
}

/// A method signature.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MethodSignature
{
    /// The return type.
    pub ret: Type,
    /// The parameter types.
    pub parameters: Vec<Type>,
}

impl MethodSignature
{
    pub fn parse_descriptor(s: &str) -> Option<Self> {
        let closing_paren_idx = s.chars().position(|c| c == ')').unwrap();
        let (mut before_paren, mut after_paren) = s.split_at(closing_paren_idx);

        before_paren = &before_paren[1..]; // Eat the opening parenthesis.
        after_paren = &after_paren[1..]; // Eat the closing parenthesis

        // Eat semicolons.
        if before_paren.chars().last() == Some(';') {
            before_paren = &before_paren[0..before_paren.len()-1];
        }
        if after_paren.chars().last() == Some(';') {
            after_paren = &after_paren[0..after_paren.len()-1];
        }

        let ret = match Type::parse_descriptor(after_paren) {
            Some(ty) => ty,
            None => return None,
        };

        let mut parameters = Vec::new();
        let mut chars_read = 0;

        while chars_read != before_paren.len() {
            let param_ty = Type::parse_descriptor(&before_paren[chars_read..]).unwrap();

            chars_read += param_ty.descriptor().len();
            parameters.push(param_ty);
        }

        Some(MethodSignature {
            ret: ret,
            parameters: parameters,
        })
    }

    pub fn descriptor(&self) -> String {
        let parameter_descriptors: Vec<_> = self.parameters.iter().map(Type::descriptor).collect();
        let param_descriptor = format!("{};", parameter_descriptors.join(""));
        format!("({}){};", param_descriptor, self.ret.descriptor())
    }
}

#[cfg(test)]
mod test
{
    use {Type, PrimitiveType};
    use super::*;

    #[test]
    fn basic_signature_has_correct_descriptor() {
        let sig = MethodSignature {
            ret: Type::Class { name: "java/lang/Object".to_owned() },
            parameters: vec![
                Type::Primitive(PrimitiveType::Integer),
                Type::Primitive(PrimitiveType::Double),
                Type::Class { name: "java/lang/Thread".to_owned() },
            ],
        };

        assert_eq!(sig.descriptor(), "(IDLjava/lang/Thread;)Ljava/lang/Object;");
    }

    #[test]
    fn can_parse_basic_sig() {
        let sig = MethodSignature::parse_descriptor("(IDLjava/lang/Thread;)Ljava/lang/Object;");
        assert_eq!(sig, Some(MethodSignature {
            ret: Type::Class { name: "java/lang/Object".to_owned() },
            parameters: vec![
                Type::Primitive(PrimitiveType::Integer),
                Type::Primitive(PrimitiveType::Double),
                Type::Class { name: "java/lang/Thread".to_owned() },
            ],
        }));
    }

    #[test]
    fn can_parse_void_sig() {
        let sig = MethodSignature::parse_descriptor("()V");
        assert_eq!(sig, Some(MethodSignature {
            ret: Type::Primitive(PrimitiveType::Void),
            parameters: Vec::new(),
        }));
    }
}