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
29impl 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}