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
use super::WhileLoop;
use crate::build_config::BuildConfig;
use crate::parser::Rule;
use crate::span::Span;
use crate::{
error::*,
parse_tree::{Expression, ReturnStatement},
span, AstNode, AstNodeContent, Declaration,
};
use pest::iterators::Pair;
#[derive(Debug, Clone)]
pub struct CodeBlock<'sc> {
pub contents: Vec<AstNode<'sc>>,
pub(crate) whole_block_span: Span<'sc>,
}
impl<'sc> CodeBlock<'sc> {
pub(crate) fn parse_from_pair(
block: Pair<'sc, Rule>,
config: Option<&BuildConfig>,
) -> CompileResult<'sc, Self> {
let path = config.map(|c| c.path());
let mut warnings = Vec::new();
let mut errors = Vec::new();
let whole_block_span = span::Span {
span: block.as_span(),
path: path.clone(),
};
let block_inner = block.into_inner();
let mut contents = Vec::new();
for pair in block_inner {
contents.push(match pair.as_rule() {
Rule::declaration => AstNode {
content: AstNodeContent::Declaration(check!(
Declaration::parse_from_pair(pair.clone(), config),
continue,
warnings,
errors
)),
span: span::Span {
span: pair.as_span(),
path: path.clone(),
},
},
Rule::expr_statement => {
let evaluated_node = check!(
Expression::parse_from_pair(
pair.clone().into_inner().next().unwrap().clone(),
config
),
continue,
warnings,
errors
);
AstNode {
content: AstNodeContent::Expression(evaluated_node),
span: span::Span {
span: pair.as_span(),
path: path.clone(),
},
}
}
Rule::return_statement => {
let evaluated_node = check!(
ReturnStatement::parse_from_pair(pair.clone(), config),
continue,
warnings,
errors
);
AstNode {
content: AstNodeContent::ReturnStatement(evaluated_node),
span: span::Span {
span: pair.as_span(),
path: path.clone(),
},
}
}
Rule::expr => {
let res = check!(
Expression::parse_from_pair(pair.clone(), config),
continue,
warnings,
errors
);
AstNode {
content: AstNodeContent::ImplicitReturnExpression(res.clone()),
span: res.span(),
}
}
Rule::while_loop => {
let res = check!(
WhileLoop::parse_from_pair(pair.clone(), config),
continue,
warnings,
errors
);
AstNode {
content: AstNodeContent::WhileLoop(res),
span: span::Span {
span: pair.as_span(),
path: path.clone(),
},
}
}
a => {
println!("In code block parsing: {:?} {:?}", a, pair.as_str());
errors.push(CompileError::UnimplementedRule(
a,
span::Span {
span: pair.as_span(),
path: path.clone(),
},
));
continue;
}
})
}
ok(
CodeBlock {
whole_block_span,
contents,
},
warnings,
errors,
)
}
}