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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
use std::error;
use std::fmt;
use ast::*;
use nom;
pub enum ErrorType {
TypeFail,
DuplicateBinding,
IncompleteParsing,
Unsupported,
NoSuchSymbol,
BadArgLen,
FormatError,
UnexpectedToken,
EmptyExpression,
ParseError,
}
impl fmt::Display for ErrorType {
fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
let name = match self {
&ErrorType::TypeFail => "TypeFail",
&ErrorType::DuplicateBinding => "DuplicateBinding",
&ErrorType::IncompleteParsing => "IncompleteParsing",
&ErrorType::Unsupported => "Unsupported",
&ErrorType::NoSuchSymbol => "NoSuchSymbol",
&ErrorType::BadArgLen => "BadArgLen",
&ErrorType::FormatError => "FormatError",
&ErrorType::UnexpectedToken => "UnexpectedToken",
&ErrorType::EmptyExpression => "EmptyExpression",
&ErrorType::ParseError => "ParseError",
};
w.write_str(name)
}
}
pub struct Error {
pub err_type: ErrorType,
pub pos: Position,
pub msg: String,
pub cause: Option<Box<Error>>,
_pkgonly: (),
}
impl Error {
pub fn new<S: Into<String>>(msg: S, t: ErrorType, pos: Position) -> Self {
Error {
err_type: t,
pos: pos,
msg: msg.into(),
cause: None,
_pkgonly: (),
}
}
pub fn new_with_cause<S: Into<String>>(msg: S, t: ErrorType, cause: Error) -> Self {
let mut e = Self::new(msg, t, cause.pos.clone());
e.cause = Some(Box::new(cause));
return e;
}
pub fn new_with_errorkind<S: Into<String>>(
msg: S,
t: ErrorType,
pos: Position,
cause: nom::ErrorKind<Error>,
) -> Self {
match cause {
nom::ErrorKind::Custom(e) => Self::new_with_cause(msg, t, e),
_ => Self::new(msg, t, pos),
}
}
fn render(&self, w: &mut fmt::Formatter) -> fmt::Result {
try!(write!(
w,
"{}: \"{}\" at line: {} column: {}",
self.err_type, self.msg, self.pos.line, self.pos.column
));
if let Some(ref cause) = self.cause {
try!(write!(w, "\n\tCaused By: {}", cause));
}
Ok(())
}
}
impl fmt::Debug for Error {
fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
self.render(w)
}
}
impl fmt::Display for Error {
fn fmt(&self, w: &mut fmt::Formatter) -> fmt::Result {
self.render(w)
}
}
impl error::Error for Error {
fn description(&self) -> &str {
&self.msg
}
}