lvm-class 0.4.1

JVM class file parser and writer for the Lagertha VM project
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

//! Shared attribute types that can appear at multiple locations in a class file.
//!
//! These attributes can be attached to classes, fields, methods, and record components.

use super::AttributeKind;
use super::annotation::Annotation;
use super::type_annotation::TypeAnnotation;
use crate::ClassFormatErr;
use lvm_common::utils::cursor::ByteCursor;

/// Attribute payloads that can appear at multiple locations (class, field, method, record).
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SharedAttribute {
    Synthetic {
        attr_name_idx: u16,
    },
    Deprecated {
        attr_name_idx: u16,
    },
    Signature {
        attr_name_idx: u16,
        signature_idx: u16,
    },
    RuntimeVisibleAnnotations {
        attr_name_idx: u16,
        annotations: Vec<Annotation>,
    },
    RuntimeInvisibleAnnotations {
        attr_name_idx: u16,
        annotations: Vec<Annotation>,
    },
    RuntimeVisibleTypeAnnotations {
        attr_name_idx: u16,
        annotations: Vec<TypeAnnotation>,
    },
    RuntimeInvisibleTypeAnnotations {
        attr_name_idx: u16,
        annotations: Vec<TypeAnnotation>,
    },
}

impl<'a> SharedAttribute {
    pub(crate) fn read(
        attr_name_idx: u16,
        attr_type: AttributeKind,
        cursor: &mut ByteCursor<'a>,
    ) -> Result<Self, ClassFormatErr> {
        match attr_type {
            AttributeKind::Synthetic => Ok(SharedAttribute::Synthetic { attr_name_idx }),
            AttributeKind::Deprecated => Ok(SharedAttribute::Deprecated { attr_name_idx }),
            AttributeKind::Signature => {
                let signature_idx = cursor.u16()?;
                Ok(SharedAttribute::Signature {
                    attr_name_idx,
                    signature_idx,
                })
            }
            AttributeKind::RuntimeVisibleAnnotations => {
                let num_annotations = cursor.u16()?;
                let mut annotations = Vec::with_capacity(num_annotations as usize);
                for _ in 0..num_annotations {
                    annotations.push(Annotation::read(cursor)?);
                }
                Ok(SharedAttribute::RuntimeVisibleAnnotations {
                    attr_name_idx,
                    annotations,
                })
            }
            AttributeKind::RuntimeInvisibleAnnotations => {
                let num_annotations = cursor.u16()?;
                let mut annotations = Vec::with_capacity(num_annotations as usize);
                for _ in 0..num_annotations {
                    annotations.push(Annotation::read(cursor)?);
                }
                Ok(SharedAttribute::RuntimeInvisibleAnnotations {
                    attr_name_idx,
                    annotations,
                })
            }
            AttributeKind::RuntimeInvisibleTypeAnnotations => {
                let num_annotations = cursor.u16()?;
                let mut annotations = Vec::with_capacity(num_annotations as usize);
                for _ in 0..num_annotations {
                    annotations.push(TypeAnnotation::read(cursor)?);
                }
                Ok(SharedAttribute::RuntimeInvisibleTypeAnnotations {
                    attr_name_idx,
                    annotations,
                })
            }
            AttributeKind::RuntimeVisibleTypeAnnotations => {
                let num_annotations = cursor.u16()?;
                let mut annotations = Vec::with_capacity(num_annotations as usize);
                for _ in 0..num_annotations {
                    annotations.push(TypeAnnotation::read(cursor)?);
                }
                Ok(SharedAttribute::RuntimeVisibleTypeAnnotations {
                    attr_name_idx,
                    annotations,
                })
            }
            _ => Err(ClassFormatErr::AttributeIsNotShared(attr_type.to_string())),
        }
    }
}