dellingr 0.4.0

An embeddable, pure-Rust Lua VM with precise instruction-cost accounting
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

use core::fmt;

/// Error type returned by _try methods
#[derive(Clone, PartialEq, Debug)]
pub(crate) enum PatternError {
    InvalidPatternCapture,
    InvalidCaptureIndex(Option<i8>),
    MalformedPattern(MalformedPattern),
    TooManyCaptures,
    MatchDepthExceeded,
    UnfinishedCapture,
}

/// Error returned while executing a compiled Lua pattern.
#[derive(PartialEq, Debug)]
pub(crate) enum MatchError {
    Pattern(PatternError),
    BudgetExceeded,
}

impl From<PatternError> for MatchError {
    fn from(error: PatternError) -> Self {
        Self::Pattern(error)
    }
}

#[derive(Clone, Copy, PartialEq, Debug)]
pub(crate) enum MalformedPattern {
    EndsWithPercent,
    MissingBalancedArguments,
    MissingBracket,
    MissingFrontierBracket,
}

impl MalformedPattern {
    const fn as_str(self) -> &'static str {
        match self {
            Self::EndsWithPercent => "ends with '%'",
            Self::MissingBalancedArguments => "missing arguments to '%b'",
            Self::MissingBracket => "missing ']'",
            Self::MissingFrontierBracket => "missing '[' after '%f' in pattern",
        }
    }
}

impl fmt::Display for PatternError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::InvalidPatternCapture => write!(f, "invalid pattern capture"),
            Self::InvalidCaptureIndex(None) => write!(f, "invalid capture index"),
            Self::InvalidCaptureIndex(Some(idx)) => {
                write!(f, "invalid capture index %{}", i16::from(*idx) + 1)
            }
            Self::MalformedPattern(what) => {
                let what = what.as_str();
                write!(f, "malformed pattern ({what})")
            }
            Self::TooManyCaptures => write!(f, "too many captures"),
            Self::MatchDepthExceeded => write!(f, "pattern too complex"),
            Self::UnfinishedCapture => write!(f, "unfinished capture"),
        }
    }
}