bsharp_fset/
error.rs

1use super::*;
2use parser::ParseError;
3use tokens::TokenizeError;
4
5pub enum FSetError {
6    ParseError(ParseError),
7    TokenizeError(TokenizeError),
8    IOError(std::io::Error),
9}
10
11impl From<ParseError> for FSetError {
12    fn from(e: ParseError) -> FSetError {
13        FSetError::ParseError(e)
14    }
15}
16
17impl From<TokenizeError> for FSetError {
18    fn from(e: TokenizeError) -> FSetError {
19        FSetError::TokenizeError(e)
20    }
21}
22
23impl From<std::io::Error> for FSetError {
24    fn from(e: std::io::Error) -> FSetError {
25        FSetError::IOError(e)
26    }
27}
28
29// Impl display for FSetError
30impl FSetError {
31    pub fn pos(&self) -> Option<Pos> {
32        match self {
33            FSetError::IOError(_) => None,
34            FSetError::ParseError(e) => match e {
35                ParseError::UnexpectedToken(t) => Some(t.pos),
36                ParseError::EOF => None,
37            },
38            FSetError::TokenizeError(e) => match e {
39                TokenizeError::UnexpectedToken { got: t, .. } => Some(t.pos),
40                TokenizeError::EOF => None,
41                TokenizeError::UnexpectedChar(_, pos) => Some(*pos),
42                TokenizeError::InvalidEscapeCode(_, pos) => Some(*pos),
43                TokenizeError::InvalidInt(_, pos) => Some(*pos),
44                TokenizeError::InvalidFloat(_, pos) => Some(*pos),
45            },
46        }
47    }
48
49    pub fn msg(&self) -> String {
50        match self {
51            FSetError::ParseError(e) => match e {
52                ParseError::UnexpectedToken(_) => "unexpected token".to_string(),
53                ParseError::EOF => "parse error: un-closed bracket".to_string(),
54            },
55            FSetError::TokenizeError(e) => match e {
56                TokenizeError::UnexpectedToken { .. } => "unexpected token".to_string(),
57                TokenizeError::EOF => format!("tokenize error: unexpected EOF"),
58                TokenizeError::UnexpectedChar(c, ..) => {
59                    format!("invalid character '{}'", c)
60                }
61                TokenizeError::InvalidEscapeCode(c, ..) => {
62                    format!("invalid escape code '{}'", c)
63                }
64                TokenizeError::InvalidInt(val, ..) => {
65                    format!("invalid integer '{}'", val)
66                }
67                TokenizeError::InvalidFloat(val, ..) => {
68                    format!("invalid float '{}'", val)
69                }
70            },
71            FSetError::IOError(e) => e.to_string(),
72        }
73    }
74
75    pub fn fmt(&self, fset: &FSet) -> String {
76        match self {
77            FSetError::ParseError(e) => match e {
78                ParseError::UnexpectedToken(t) => {
79                    format!("{}: unexpected token", fset.display_pos(&t.pos))
80                }
81                ParseError::EOF => format!("parse error: un-closed bracket"),
82            },
83            FSetError::TokenizeError(e) => match e {
84                TokenizeError::UnexpectedToken { got: t, .. } => {
85                    format!("{}: unexpected token", fset.display_pos(&t.pos))
86                }
87                TokenizeError::EOF => format!("tokenize error: unexpected EOF"),
88                TokenizeError::UnexpectedChar(c, pos) => {
89                    format!("{}: invalid character '{}'", fset.display_pos(&pos), c)
90                }
91                TokenizeError::InvalidEscapeCode(c, pos) => {
92                    format!("{}: invalid escape code '{}'", fset.display_pos(&pos), c)
93                }
94                TokenizeError::InvalidInt(val, pos) => {
95                    format!("{}: invalid integer '{}'", fset.display_pos(&pos), val)
96                }
97                TokenizeError::InvalidFloat(val, pos) => {
98                    format!("{}: invalid float '{}'", fset.display_pos(&pos), val)
99                }
100            },
101            FSetError::IOError(e) => e.to_string(),
102        }
103    }
104}