jreflection 0.0.11

Static reflection APIs for analyzing jars and jimage files
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

use crate::*;
use crate::io::be::*;

use std::io::{self, Read};



#[allow(non_camel_case_types)]
#[derive(Clone, Debug)]
pub(crate) enum Attribute {
    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.2
    ConstantValue(field::Constant),

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.3
    Code { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.4
    StackMapTable { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.5
    Exceptions { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.6
    InnerClasses { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.7
    EnclosingMethod { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.8
    Synthetic { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.9
    Signature { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.10
    SourceFile { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.11
    SourceDebugExtension { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.12
    LineNumberTable { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.13
    LocalVariableTable { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.14
    LocalVariableTypeTable { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.15
    Deprecated { #[doc(hidden)] __nyi: () },
    // Deprecated is actually completely parsed, but I'm keeping "__nyi" around in case future expansions to the JVM allow an optional deprecation message or something.

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.16
    RuntimeVisibleAnnotations { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.17
    RuntimeInvisibleAnnotations { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.18
    RuntimeVisibleParameterAnnotations { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.19
    RuntimeInvisibleParameterAnnotations { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.20
    AnnotationDefault { #[doc(hidden)] __nyi: () },

    /// https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.21
    BootstrapMethods { #[doc(hidden)] __nyi: () },

    /// An unrecognized attribute was used!
    Unknown,

    #[doc(hidden)] __NonExhaustive,
}

impl Attribute {
    pub(crate) fn read(read: &mut impl Read, constants: &Constants) -> io::Result<Self> {
        let attribute_name_index    = read_u2(read)?;
        let attribute_length        = read_u4(read)? as usize;

        let name = constants.get_utf8(attribute_name_index)?;
        match name {
            "ConstantValue" => {
                // https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.7.2
                io_assert!(attribute_length == 2);
                let constantvalue_index = read_u2(read)?;
                let constant = constants.get(constantvalue_index)?;
                match constant {
                    Constant::Long(value)               => Ok(Attribute::ConstantValue(field::Constant::Long(*value))),
                    Constant::Float(value)              => Ok(Attribute::ConstantValue(field::Constant::Float(*value))),
                    Constant::Double(value)             => Ok(Attribute::ConstantValue(field::Constant::Double(*value))),
                    Constant::Integer(value)            => Ok(Attribute::ConstantValue(field::Constant::Integer(*value))),
                    Constant::String { string_index }   => Ok(Attribute::ConstantValue(field::Constant::String(constants.get_utf8_possibly_invalid(*string_index)?.map(|s| s.to_owned())))),
                    c                                   => io_data_err!("Expected Constant::{{Long, Float, Double, Integer, String}}, got {:?}", c),
                }
            },
            "Code"                                  => { read_ignore(read, attribute_length)?; Ok(Attribute::Code                                  {__nyi:()}) },
            "StackMapTable"                         => { read_ignore(read, attribute_length)?; Ok(Attribute::StackMapTable                         {__nyi:()}) },
            "Exceptions"                            => { read_ignore(read, attribute_length)?; Ok(Attribute::Exceptions                            {__nyi:()}) },
            "InnerClasses"                          => { read_ignore(read, attribute_length)?; Ok(Attribute::InnerClasses                          {__nyi:()}) },
            "EnclosingMethod"                       => { read_ignore(read, attribute_length)?; Ok(Attribute::EnclosingMethod                       {__nyi:()}) },
            "Synthetic"                             => { read_ignore(read, attribute_length)?; Ok(Attribute::Synthetic                             {__nyi:()}) },
            "Signature"                             => { read_ignore(read, attribute_length)?; Ok(Attribute::Signature                             {__nyi:()}) },
            "SourceFile"                            => { read_ignore(read, attribute_length)?; Ok(Attribute::SourceFile                            {__nyi:()}) },
            "SourceDebugExtension"                  => { read_ignore(read, attribute_length)?; Ok(Attribute::SourceDebugExtension                  {__nyi:()}) },
            "LineNumberTable"                       => { read_ignore(read, attribute_length)?; Ok(Attribute::LineNumberTable                       {__nyi:()}) },
            "LocalVariableTable"                    => { read_ignore(read, attribute_length)?; Ok(Attribute::LocalVariableTable                    {__nyi:()}) },
            "LocalVariableTypeTable"                => { read_ignore(read, attribute_length)?; Ok(Attribute::LocalVariableTypeTable                {__nyi:()}) },
            "Deprecated"                            => { read_ignore(read, attribute_length)?; Ok(Attribute::Deprecated                            {__nyi:()}) },
            "RuntimeVisibleAnnotations"             => { read_ignore(read, attribute_length)?; Ok(Attribute::RuntimeVisibleAnnotations             {__nyi:()}) },
            "RuntimeInvisibleAnnotations"           => { read_ignore(read, attribute_length)?; Ok(Attribute::RuntimeInvisibleAnnotations           {__nyi:()}) },
            "RuntimeVisibleParameterAnnotations"    => { read_ignore(read, attribute_length)?; Ok(Attribute::RuntimeVisibleParameterAnnotations    {__nyi:()}) },
            "RuntimeInvisibleParameterAnnotations"  => { read_ignore(read, attribute_length)?; Ok(Attribute::RuntimeInvisibleParameterAnnotations  {__nyi:()}) },
            "AnnotationDefault"                     => { read_ignore(read, attribute_length)?; Ok(Attribute::AnnotationDefault                     {__nyi:()}) },
            "BootstrapMethods"                      => { read_ignore(read, attribute_length)?; Ok(Attribute::BootstrapMethods                      {__nyi:()}) },
            _                                       => { read_ignore(read, attribute_length)?; Ok(Attribute::Unknown) },
        }
    }
}