rsaeb 0.5.0

A no_std + alloc interpreter for A=B ordered rewrite programs.
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

use core::error::Error;

use crate::allocation::AllocationError;
use crate::bytes::TraceSnapshotByteCount;
use crate::program::TraceSnapshotByteLimit;

use super::RunError;

/// Error returned by fallible tracing APIs.
#[derive(Debug, PartialEq, Eq)]
pub enum TracedRunError<E> {
    /// Runtime execution failed.
    Run(RunError),
    /// The user-provided trace sink failed.
    Trace(E),
}

impl<E> Error for TracedRunError<E>
where
    E: Error + 'static,
{
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Run(error) => Some(error),
            Self::Trace(error) => Some(error),
        }
    }
}

impl<E> From<RunError> for TracedRunError<E> {
    fn from(value: RunError) -> Self {
        Self::Run(value)
    }
}

/// Error while materializing an owned trace snapshot from a borrowed trace event.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TraceSnapshotError {
    /// Snapshot bytes exceeded the caller-provided snapshot byte limit.
    Limit {
        /// Configured maximum trace snapshot byte length.
        limit: TraceSnapshotByteLimit,
        /// Snapshot length that would have been allocated.
        attempted_len: TraceSnapshotByteCount,
    },
    /// Snapshot byte materialization failed.
    Allocation(AllocationError),
}

impl Error for TraceSnapshotError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Limit { .. } => None,
            Self::Allocation(error) => Some(error),
        }
    }
}

impl From<AllocationError> for TraceSnapshotError {
    fn from(value: AllocationError) -> Self {
        Self::Allocation(value)
    }
}

/// Error returned by infallible trace-snapshot APIs.
#[derive(Debug, PartialEq, Eq)]
pub enum TraceSnapshotRunError {
    /// Runtime execution failed.
    Run(RunError),
    /// Trace snapshot materialization failed.
    Snapshot(TraceSnapshotError),
}

impl Error for TraceSnapshotRunError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Run(error) => Some(error),
            Self::Snapshot(error) => Some(error),
        }
    }
}

impl From<RunError> for TraceSnapshotRunError {
    fn from(value: RunError) -> Self {
        Self::Run(value)
    }
}

impl From<TraceSnapshotError> for TraceSnapshotRunError {
    fn from(value: TraceSnapshotError) -> Self {
        Self::Snapshot(value)
    }
}

/// Error returned by fallible trace-snapshot APIs.
#[derive(Debug, PartialEq, Eq)]
pub enum FallibleTraceSnapshotRunError<E> {
    /// Runtime execution failed.
    Run(RunError),
    /// Trace snapshot materialization failed.
    Snapshot(TraceSnapshotError),
    /// The user-provided trace sink failed.
    Trace(E),
}

impl<E> Error for FallibleTraceSnapshotRunError<E>
where
    E: Error + 'static,
{
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            Self::Run(error) => Some(error),
            Self::Snapshot(error) => Some(error),
            Self::Trace(error) => Some(error),
        }
    }
}

impl<E> From<RunError> for FallibleTraceSnapshotRunError<E> {
    fn from(value: RunError) -> Self {
        Self::Run(value)
    }
}

impl<E> From<TraceSnapshotError> for FallibleTraceSnapshotRunError<E> {
    fn from(value: TraceSnapshotError) -> Self {
        Self::Snapshot(value)
    }
}