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
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

use std::io::Read;

use byteorder::{BigEndian, ReadBytesExt};

use crate::node::attribute::{
    Attribute, Object, StackMapFrameEntry, StackMapTable, VerificationType,
};
use crate::parse::error::{ParseError, ParseResult};

#[inline]
pub(super) fn stack_map_table<R: Read>(input: &mut R) -> ParseResult<Option<Attribute>> {
    let number_of_entries = input.read_u16::<BigEndian>()?;
    let mut entries = Vec::with_capacity(number_of_entries as usize);

    for _ in 0..number_of_entries {
        entries.push(stack_map_frame_entry(input)?);
    }

    Ok(Some(Attribute::StackMapTable(StackMapTable {
        number_of_entries,
        entries,
    })))
}

fn stack_map_frame_entry<R: Read>(input: &mut R) -> ParseResult<StackMapFrameEntry> {
    let frame_type = input.read_u8()?;

    match frame_type {
        0..=63 => Ok(StackMapFrameEntry::Same { frame_type }),
        64..=127 => {
            let stack = verification_type(input)?;

            Ok(StackMapFrameEntry::SameLocal1StackItem { frame_type, stack })
        }
        247 => {
            let offset_delta = input.read_u16::<BigEndian>()?;
            let stack = verification_type(input)?;

            Ok(StackMapFrameEntry::SameLocal1StackItemExtended {
                frame_type,
                offset_delta,
                stack,
            })
        }
        248..=250 => {
            let offset_delta = input.read_u16::<BigEndian>()?;

            Ok(StackMapFrameEntry::Chop {
                frame_type,
                offset_delta,
            })
        }
        251 => {
            let offset_delta = input.read_u16::<BigEndian>()?;

            Ok(StackMapFrameEntry::SameExtended {
                frame_type,
                offset_delta,
            })
        }
        252..=254 => {
            let offset_delta = input.read_u16::<BigEndian>()?;
            let mut locals = Vec::with_capacity(frame_type as usize - 251);

            for _ in 0..frame_type - 251 {
                locals.push(verification_type(input)?);
            }

            Ok(StackMapFrameEntry::Append {
                frame_type,
                offset_delta,
                locals,
            })
        }
        255 => {
            let offset_delta = input.read_u16::<BigEndian>()?;
            let number_of_locals = input.read_u16::<BigEndian>()?;
            let mut locals = Vec::with_capacity(number_of_locals as usize);

            for _ in 0..number_of_locals {
                locals.push(verification_type(input)?);
            }

            let number_of_stack_items = input.read_u16::<BigEndian>()?;
            let mut stack = Vec::with_capacity(number_of_locals as usize);

            for _ in 0..number_of_stack_items {
                stack.push(verification_type(input)?);
            }

            Ok(StackMapFrameEntry::Full {
                frame_type,
                offset_delta,
                number_of_locals,
                locals,
                number_of_stack_items,
                stack,
            })
        }
        _ => Err(ParseError::MatchOutOfBoundUsize(
            "stack map frame entry",
            vec![
                "0..=63",
                "64..=127",
                "247",
                "248..=250",
                "251",
                "252..=254",
                "255",
            ],
            frame_type as usize,
        )),
    }
}

fn verification_type<R: Read>(input: &mut R) -> ParseResult<VerificationType> {
    let tag = input.read_u8()?;

    match tag {
        0 => Ok(VerificationType::Top),
        1 => Ok(VerificationType::Integer),
        2 => Ok(VerificationType::Float),
        3 => Ok(VerificationType::Double),
        4 => Ok(VerificationType::Long),
        5 => Ok(VerificationType::Null),
        6 => Ok(VerificationType::UninitializedThis),
        7 => {
            let cpool_index = input.read_u16::<BigEndian>()?;

            Ok(VerificationType::Object(Object { cpool_index }))
        }
        8 => {
            let offset = input.read_u16::<BigEndian>()?;

            Ok(VerificationType::Uninitialized { offset })
        }
        _ => Err(ParseError::MatchOutOfBoundUsize(
            "verification type",
            vec!["0..=8"],
            tag as usize,
        )),
    }
}