elb 0.4.0

A library that supports reading ELF files and patching RPATH, RUNPATH and interpreter.
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

macro_rules! define_infallible_enum {
    {
        $doc: literal,
        $enum: ident,
        $int: ident,
        $(($name: ident, $value: expr$(, $doc1: literal)*),)*
    } => {
        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
        #[doc = $doc]
        pub enum $enum {
            $(
                $(#[doc = $doc1])*
                $name,
            )*
            /// Other.
            Other($int),
        }

        impl $enum {
            #[inline]
            pub(crate) const fn as_number(self) -> $int {
                match self {
                    $( Self::$name => $value, )*
                    Self::Other(n) => n,
                }
            }
        }

        impl From<$int> for $enum {
            fn from(n: $int) -> Self {
                match n {
                    $( $value => Self::$name, )*
                    n => Self::Other(n),
                }
            }
        }

        #[cfg(test)]
        impl<'a> ::arbitrary::Arbitrary<'a> for $enum {
            fn arbitrary(u: &mut ::arbitrary::Unstructured<'a>) -> ::arbitrary::Result<Self> {
                let number: $int = u.arbitrary()?;
                Ok($enum::from(number))
            }
        }
    };
}

pub(crate) use define_infallible_enum;

macro_rules! define_enum_v2 {
    {
        $doc: literal,
        $enum: ident,
        $int: ident,
        $(($name: ident, $value: expr$(, $doc1: literal)*),)*
    } => {
        #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
        #[doc = $doc]
        pub enum $enum {
            $(
                $(#[doc = $doc1])*
                $name,
            )*
            /// Other.
            Other($int),
        }

        impl $enum {
            #[inline]
            pub(crate) const fn as_number(self) -> $int {
                match self {
                    $( Self::$name => $value, )*
                    Self::Other(n) => n,
                }
            }

            pub(crate) fn from(n: $int) -> Self {
                match n {
                    $( $value => Self::$name, )*
                    n => Self::Other(n),
                }
            }
        }
    };
}

pub(crate) use define_enum_v2;