wasmi_core 2.0.0-beta.0

Core primitives for the wasmi WebAssembly 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
88
89
90
91
92
93
94
95
96
97
98

macro_rules! float {
    (
        $( #[$docs:meta] )*
        struct $name:ident($prim:ty as $bits:ty);
    ) => {
        $(#[$docs])*
        #[derive(Copy, Clone)]
        pub struct $name($bits);

        impl $name {
            /// Creates a float from its underlying bits.
            #[inline]
            pub fn from_bits(other: $bits) -> Self {
                Self(other)
            }

            /// Returns the underlying bits of the float.
            #[inline]
            pub fn to_bits(self) -> $bits {
                self.0
            }

            /// Creates a float from the respective primitive float type.
            #[inline]
            pub fn from_float(float: $prim) -> Self {
                Self::from_bits(float.to_bits())
            }

            /// Returns the respective primitive float type.
            #[inline]
            pub fn to_float(self) -> $prim {
                <$prim>::from_bits(self.to_bits())
            }
        }

        impl ::core::convert::From<$prim> for $name {
            #[inline]
            fn from(float: $prim) -> $name {
                Self::from_float(float)
            }
        }

        impl ::core::convert::From<$name> for $prim {
            #[inline]
            fn from(float: $name) -> $prim {
                float.to_float()
            }
        }

        impl ::core::cmp::PartialEq<$name> for $name {
            #[inline]
            fn eq(&self, other: &$name) -> ::core::primitive::bool {
                self.to_float().eq(&other.to_float())
            }
        }

        impl ::core::cmp::PartialOrd<$name> for $name {
            #[inline]
            fn partial_cmp(&self, other: &$name) -> ::core::option::Option<::core::cmp::Ordering> {
                self.to_float().partial_cmp(&other.to_float())
            }
        }

        impl ::core::fmt::Debug for $name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                if self.to_float().is_nan() {
                    return core::write!(f, "nan:0x{:X?}", self.to_bits())
                }
                <$prim as ::core::fmt::Debug>::fmt(
                    &<$prim as ::core::convert::From<Self>>::from(*self),
                    f,
                )
            }
        }

        impl ::core::fmt::Display for $name {
            fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
                if self.to_float().is_nan() {
                    return core::write!(f, "nan:0x{:X?}", self.to_bits())
                }
                <$prim as ::core::fmt::Display>::fmt(
                    &<$prim as ::core::convert::From<Self>>::from(*self),
                    f,
                )
            }
        }
    };
}

float! {
    /// A 32-bit `f32` type.
    struct F32(f32 as u32);
}

float! {
    /// A 64-bit `f64` type.
    struct F64(f64 as u64);
}