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
126
127
128
129
130
131
132
133
134
135
136
use std::error;
use std::fmt;
#[derive(Debug, Clone)]
pub enum Error {
ParseError(ParseError),
TranspileError(TranspileError),
}
impl fmt::Display for Error {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
Error::ParseError(e) => write!(f, "{}", e),
Error::TranspileError(e) => write!(f, "{}", e),
}
}
}
impl error::Error for Error {}
impl From<ParseError> for Error {
fn from(error: ParseError) -> Self {
Error::ParseError(error)
}
}
impl From<TranspileError> for Error {
fn from(error: TranspileError) -> Self {
Error::TranspileError(error)
}
}
#[derive(Debug, Clone)]
pub enum ParseError {
BadSyntax(String),
BadYololNumber(String),
}
impl fmt::Display for ParseError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
ParseError::BadSyntax(s) => write!(f, "syntax error: {}", s),
ParseError::BadYololNumber(s) => write!(f, "failed to parse number: {}", s),
}
}
}
#[derive(Debug, Clone)]
pub enum TranspileError {
ImportExisting(String),
ImportKeyword(String),
ImportTwice(String),
DefineKeyword(String),
RedefineFunction(String),
AssignSameLowercase(String),
AssignToKeyword(String),
ReassignVariable(String),
ExportTwice(String),
ExportUndefined(String),
GetUndefinedFunction(String),
GetUndefinedLocal(String),
GetUndefinedVariable(String),
DuplicateParams,
RecursiveCall,
WrongNumberOfArgs(String),
MismatchedArrays,
NestedArrays,
}
impl fmt::Display for TranspileError {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match self {
TranspileError::ImportExisting(variable) => {
write!(f, "cannot import existing variable: {}", variable)
}
TranspileError::ImportKeyword(keyword) => {
write!(f, "cannot import reserved keyword: {}", keyword)
}
TranspileError::ImportTwice(variable) => write!(f, "duplicate import: {}", variable),
TranspileError::DefineKeyword(keyword) => {
write!(f, "cannot define reserved keyword: {}", keyword)
}
TranspileError::RedefineFunction(function) => {
write!(f, "cannot redefine function: {}", function)
}
TranspileError::AssignSameLowercase(variable) => write!(
f,
"multiple variable must not have the same lowercase representation: {}",
variable
),
TranspileError::AssignToKeyword(keyword) => {
write!(f, "cannot assign to keyword: {}", keyword)
}
TranspileError::ReassignVariable(variable) => {
write!(f, "cannot reassign variable: {}", variable)
}
TranspileError::ExportTwice(variable) => write!(f, "duplicate export: {}", variable),
TranspileError::ExportUndefined(variable) => {
write!(f, "cannot export undefined variable: {}", variable)
}
TranspileError::GetUndefinedFunction(function) => {
write!(f, "undefined function: {}", function)
}
TranspileError::GetUndefinedLocal(local) => {
write!(f, "undefined local variable: {}", local)
}
TranspileError::GetUndefinedVariable(variable) => {
write!(f, "undefined variable: {}", variable)
}
TranspileError::DuplicateParams => write!(f, "duplicate function parameters"),
TranspileError::RecursiveCall => write!(f, "cannot define function recursively"),
TranspileError::WrongNumberOfArgs(function) => {
write!(f, "wrong number of args for function: {}", function)
}
TranspileError::MismatchedArrays => write!(f, "cannot operate on mismatched arrays"),
TranspileError::NestedArrays => write!(f, "cannot create nested arrays"),
}
}
}