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

use alloc::vec::Vec;

use crate::allocation::{AllocationContext, try_push, try_reserve_total_exact};
use crate::bytes::{RuntimeByte, RuntimeStateByteCount};
use crate::error::{InputError, LimitError, RunError, RuntimeInvariantError, StateLimitContext};
use crate::program::RunLimits;

/// Borrowed runtime input after ASCII validation.
///
/// Runtime input is a separate byte domain from program source. It may contain
/// ASCII whitespace, control bytes, and reserved syntax bytes, but it cannot
/// contain non-ASCII bytes.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct RuntimeInput<'input> {
    bytes: &'input [u8],
}

impl<'input> RuntimeInput<'input> {
    /// Validates raw bytes as runtime input.
    ///
    /// # Errors
    ///
    /// Returns `InputError` if any input byte is non-ASCII or if its one-based
    /// column cannot be represented.
    pub fn validate(input: &'input [u8]) -> Result<Self, InputError> {
        for (zero_based_column, byte) in input.iter().copied().enumerate() {
            RuntimeByte::validate_input(byte, zero_based_column)?;
        }

        Ok(Self { bytes: input })
    }

    /// Borrow the validated input bytes.
    #[must_use]
    pub const fn as_bytes(self) -> &'input [u8] {
        self.bytes
    }

    /// Runtime input length in bytes.
    #[must_use]
    pub const fn byte_count(self) -> RuntimeStateByteCount {
        RuntimeStateByteCount::new(self.bytes.len())
    }

    /// Whether this runtime input contains no bytes.
    #[must_use]
    pub const fn is_empty(self) -> bool {
        self.bytes.is_empty()
    }

    pub(super) fn runtime_bytes(
        self,
    ) -> impl Iterator<Item = Result<RuntimeByte, RuntimeInvariantError>> + 'input {
        self.bytes
            .iter()
            .copied()
            .map(RuntimeByte::from_validated_input)
    }
}

/// Runtime input materialized into the mutable execution byte domain.
#[derive(Debug, PartialEq, Eq)]
pub(super) struct InitialStateBytes {
    pub(super) bytes: Vec<RuntimeByte>,
}

impl InitialStateBytes {
    pub(super) fn materialize(
        input: RuntimeInput<'_>,
        limits: RunLimits,
    ) -> Result<Self, RunError> {
        let byte_count = input.byte_count();

        if byte_count.get() > limits.state_byte_limit().get() {
            return Err(LimitError::state(
                StateLimitContext::Input,
                limits.state_byte_limit(),
                byte_count,
            )
            .into());
        }

        let mut bytes = Vec::new();
        try_reserve_total_exact(
            &mut bytes,
            input.as_bytes().len(),
            AllocationContext::RuntimeInput,
        )?;

        for byte in input.runtime_bytes() {
            try_push(&mut bytes, byte?, AllocationContext::RuntimeInput)?;
        }

        Ok(Self { bytes })
    }
}