tsuki 0.4.8

Lua 5.4 ported to Rust
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

use alloc::borrow::Cow;
use alloc::string::String;
use core::error::Error;
use core::ffi::c_int;
use core::fmt::{Display, Formatter};

/// Represents an error when failed to parse Lua source.
#[derive(Debug)]
pub enum ParseError {
    /// Limit has been reached on an item (e.g. local variables).
    ItemLimit {
        /// Name of the item.
        name: &'static str,
        /// Limit of the item.
        limit: c_int,
        /// Line number that cause the limit to exceed.
        line: c_int,
    },
    /// Source error (e.g. syntax error).
    Source {
        /// Reason of the error.
        reason: String,
        /// Token that cause the error.
        token: Option<Cow<'static, str>>,
        /// Line number that cause the error.
        line: c_int,
    },
}

impl ParseError {
    pub fn line(&self) -> c_int {
        match self {
            Self::ItemLimit {
                name: _,
                limit: _,
                line,
            } => *line,
            Self::Source {
                reason: _,
                token: _,
                line,
            } => *line,
        }
    }
}

impl Error for ParseError {}

impl Display for ParseError {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Self::ItemLimit {
                name,
                limit,
                line: _,
            } => {
                write!(f, "too many {} (limit is {})", name, limit)
            }
            Self::Source {
                reason,
                token,
                line: _,
            } => match token {
                Some(t) => write!(f, "{reason} near {t}"),
                None => write!(f, "{reason}"),
            },
        }
    }
}