cfsp 1.0.1

A JVM Bytecode Manipulation Framework inspired by ASM.
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

#[allow(unused_imports)]
use bitflags::Flags;
use std::io::Read;

use byteorder::{BigEndian, ReadBytesExt};

use crate::node::access_flag::ClassAccessFlag;
use crate::node::class::{Class, JavaVersion};
use crate::parse::attribute::attribute_info;
use crate::parse::constant::constant_pool;
use crate::parse::error::{ParseError, ParseResult};
use crate::parse::field::fields;
use crate::parse::method::methods;
use crate::parse::ParsingOption;

pub(crate) fn class<R: Read>(input: &mut R, option: ParsingOption) -> ParseResult<Class> {
    let mut magic_number = [0; 4];

    input.read_exact(&mut magic_number)?;

    match magic_number {
        [0xCA, 0xFE, 0xBA, 0xBE] => {}
        _ => return Err(ParseError::MismatchedMagicNumber(magic_number)),
    }

    let java_version = JavaVersion::from(input.read_u32::<BigEndian>()?);
    let (constant_pool_count, constant_pool) = constant_pool(input)?;
    let access_flags = ClassAccessFlag::from_bits_truncate(input.read_u16::<BigEndian>()?);
    let this_class = input.read_u16::<BigEndian>()?;
    let super_class = input.read_u16::<BigEndian>()?;
    let (interfaces_count, interfaces) = interfaces(input)?;
    let (fields_count, fields) = fields(input, &constant_pool, &option)?;
    let (methods_count, methods) = methods(input, &constant_pool, &option)?;
    let attributes_count = input.read_u16::<BigEndian>()?;
    let mut attributes = Vec::with_capacity(attributes_count as usize);

    for _ in 0..attributes_count {
        attributes.push(attribute_info(input, &constant_pool, &option)?);
    }

    Ok(Class {
        java_version,
        constant_pool_count,
        constant_pool,
        access_flag: access_flags,
        this_class,
        super_class,
        interfaces_count,
        interfaces,
        fields_count,
        fields,
        methods_count,
        methods,
        attributes_count,
        attributes,
    })
}

#[inline(always)]
fn interfaces<R: Read>(input: &mut R) -> ParseResult<(u16, Vec<u16>)> {
    let interfaces_length = input.read_u16::<BigEndian>()?;
    let mut interfaces = Vec::with_capacity(interfaces_length as usize);

    for _ in 0..interfaces_length {
        interfaces.push(input.read_u16::<BigEndian>()?);
    }

    Ok((interfaces_length, interfaces))
}