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

use crate::allocation::AllocationContext;
use crate::bytes::ReturnOutputByteCount;
use crate::error::{LimitError, RunError};
use crate::program::{ReturnOutput, StepCount};
use crate::rule::{Action, PayloadView, Rule};

use super::execution::Execution;
use super::matcher::MatchedRule;
use super::rewrite::{RewritePlacement, RewriteRequest};
use super::state::MatchedStateSpan;
use super::terminal::ExecutionTerminal;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) enum StepApplication<'program> {
    Continue,
    Return(PayloadView<'program>),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(super) struct AppliedRule<'program> {
    pub(super) step: StepCount,
    pub(super) rule: &'program Rule,
    pub(super) effect: StepApplication<'program>,
}

impl<'program> Execution<'program> {
    pub(super) fn apply_matched_rule(
        &mut self,
        matched: MatchedRule<'program>,
    ) -> Result<AppliedRule<'program>, RunError> {
        let permit = self
            .step_budget
            .reserve_next_step(self.state.byte_count())
            .map_err(RunError::from)?;

        let effect = self.apply_action_to_scratch(matched.state_match, matched.rule.action())?;
        self.once_states
            .consume(matched.schedule)
            .map_err(RunError::from)?;

        let step = self.step_budget.commit(permit);

        match effect {
            StepApplication::Continue => {
                self.state.swap_with_scratch(&mut self.scratch);
                Ok(AppliedRule {
                    step,
                    rule: matched.rule,
                    effect: StepApplication::Continue,
                })
            }
            StepApplication::Return(output) => {
                self.terminal = ExecutionTerminal::Return {
                    step,
                    rule: matched.rule,
                    output,
                };
                Ok(AppliedRule {
                    step,
                    rule: matched.rule,
                    effect: StepApplication::Return(output),
                })
            }
        }
    }

    pub(super) fn materialize_return_output(
        output: PayloadView<'program>,
    ) -> Result<ReturnOutput, RunError> {
        Ok(ReturnOutput::from_vec(
            output.to_vec_with_context(AllocationContext::ReturnOutput)?,
        ))
    }

    fn apply_action_to_scratch(
        &mut self,
        state_match: MatchedStateSpan,
        action: &'program Action,
    ) -> Result<StepApplication<'program>, RunError> {
        match action {
            Action::Replace(rhs) => {
                self.state.rewrite_into(
                    RewriteRequest::new(state_match, rhs, RewritePlacement::Replace),
                    &mut self.scratch,
                    self.limits,
                )?;
                Ok(StepApplication::Continue)
            }
            Action::MoveStart(rhs) => {
                self.state.rewrite_into(
                    RewriteRequest::new(state_match, rhs, RewritePlacement::MoveStart),
                    &mut self.scratch,
                    self.limits,
                )?;
                Ok(StepApplication::Continue)
            }
            Action::MoveEnd(rhs) => {
                self.state.rewrite_into(
                    RewriteRequest::new(state_match, rhs, RewritePlacement::MoveEnd),
                    &mut self.scratch,
                    self.limits,
                )?;
                Ok(StepApplication::Continue)
            }
            Action::Return(output) => {
                let output_len = ReturnOutputByteCount::new(output.len());
                if output_len.get() > self.limits.return_byte_limit().get() {
                    return Err(LimitError::return_output(
                        self.limits.return_byte_limit(),
                        output_len,
                    )
                    .into());
                }

                Ok(StepApplication::Return(PayloadView::new(output)))
            }
        }
    }
}