mech_syntax/
statements.rs

1#[macro_use]
2use crate::*;
3use nom::sequence::tuple as nom_tuple;
4
5// #### Statements
6
7// comment_sigil := "--" | "//" ;
8pub fn comment_sigil(input: ParseString) -> ParseResult<()> {
9  let (input, _) = alt((tag("--"),tag("//")))(input)?;
10  Ok((input, ()))
11}
12
13// comment := comment_singleline | comment_multiline ;
14pub fn comment(input: ParseString) -> ParseResult<Comment> {
15  let (input, cmmnt) = alt((comment_singleline, comment_multiline))(input)?;
16  Ok((input, cmmnt))
17}
18
19// comment_singleline := ws0, comment_sigil, text+ ;
20pub fn comment_singleline(input: ParseString) -> ParseResult<Comment> {
21  let (input, _) = whitespace0(input)?;
22  let (input, _) = comment_sigil(input)?;
23  let (input, mut text) = many1(text)(input)?;
24  Ok((input, Comment{text: Token::merge_tokens(&mut text).unwrap()}))
25}
26
27// comment_multiline := whitespace*, "/*", (!"*/", whitespace* | text)+, "*/" ;
28pub fn comment_multiline(input: ParseString) -> ParseResult<Comment> {
29  let (input, _) = whitespace0(input)?;
30  let (input, _) = tag("/*")(input)?;
31  let (input, text) = many1(nom_tuple((is_not(tag("*/")),alt((text,whitespace)))))(input)?;
32  let mut text = text.iter().map(|(_,a)| a).cloned().collect::<Vec<Token>>();
33  let (input, _) = tag("*/")(input)?;
34  let (input, _) = whitespace0(input)?;
35  Ok((input, Comment{text: Token::merge_tokens(&mut text).unwrap()}))
36}
37
38// assign_operator := "=" ;
39pub fn assign_operator(input: ParseString) -> ParseResult<()> {
40  let (input, _) = whitespace0(input)?;
41  let (input, _) = tag("=")(input)?;
42  let (input, _) = whitespace0(input)?;
43  Ok((input, ()))
44}
45
46// op_assign_operator := add_assign_operator | sub_assign_operator | mul_assign_operator | div_assign_operator | exp_assign_operator ;
47pub fn op_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
48  alt((add_assign_operator, sub_assign_operator, mul_assign_operator, div_assign_operator, exp_assign_operator))(input)
49}
50
51// add_assign_operator := "+=" ;
52pub fn add_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
53  let (input, _) = whitespace0(input)?;
54  let (input, _) = tag("+=")(input)?;
55  let (input, _) = whitespace0(input)?;
56  Ok((input, OpAssignOp::Add))
57}
58
59// sub_assign_operator := "-=" ;
60pub fn sub_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
61  let (input, _) = whitespace0(input)?;
62  let (input, _) = tag("-=")(input)?;
63  let (input, _) = whitespace0(input)?;
64  Ok((input, OpAssignOp::Sub))
65}
66
67// mul_assign_operator := "*=" ;
68pub fn mul_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
69  let (input, _) = whitespace0(input)?;
70  let (input, _) = tag("*=")(input)?;
71  let (input, _) = whitespace0(input)?;
72  Ok((input, OpAssignOp::Mul))
73}
74// div_assign_operator := "/=" ;
75pub fn div_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
76  let (input, _) = whitespace0(input)?;
77  let (input, _) = tag("/=")(input)?;
78  let (input, _) = whitespace0(input)?;
79  Ok((input, OpAssignOp::Div))
80}
81
82// exp_assign_operator := "^=" ;
83pub fn exp_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
84  let (input, _) = whitespace0(input)?;
85  let (input, _) = tag("^=")(input)?;
86  let (input, _) = whitespace0(input)?;
87  Ok((input, OpAssignOp::Exp))
88}
89
90// split_data := (identifier | table), <!stmt_operator>, space*, split_operator, <space+>, <expression> ;
91/*pub fn split_data(input: ParseString) -> ParseResult<ParserNode> {
92  /*let msg1 = "Expects spaces around operator";
93  let msg2 = "Expects expression";
94  let (input, table) = alt((identifier, table))(input)?;
95  let (input, _) = labelr!(null(is_not(stmt_operator)), skip_nil, msg1)(input)?;
96  let (input, _) = many0(space)(input)?;
97  let (input, _) = split_operator(input)?;
98  let (input, _) = labelr!(null(many1(space)), skip_nil, msg1)(input)?;
99  let (input, expression) = label!(expression, msg2)(input)?;*/
100  Ok((input, ParserNode::SplitData{children: vec![]}))
101}*/
102
103// flatten_data := identifier, <!stmt_operator>, space*, flatten_operator, <space+>, <expression> ;
104/*pub fn flatten_data(input: ParseString) -> ParseResult<ParserNode> {
105  /*let msg1 = "Expects spaces around operator";
106  let msg2 = "Expects expression";
107  let (input, table) = identifier(input)?;
108  let (input, _) = labelr!(null(is_not(stmt_operator)), skip_nil, msg1)(input)?;
109  let (input, _) = many0(space)(input)?;
110  let (input, _) = flatten_operator(input)?;
111  let (input, _) = labelr!(null(many1(space)), skip_nil, msg1)(input)?;
112  let (input, expression) = label!(expression, msg2)(input)?;*/
113  Ok((input, ParserNode::FlattenData{children: vec![]}))
114}*/
115
116// variable_define := tilde?, var, !assign_operator, define_operator, expression ;
117pub fn variable_define(input: ParseString) -> ParseResult<VariableDefine> {
118  let msg1 = "Expects spaces around operator";
119  let msg2 = "Expects expression";
120  let (input, mutable) = opt(tilde)(input)?; 
121  let (input, var) = var(input)?;
122  let (input, _) = labelr!(null(is_not(assign_operator)), skip_nil, msg1)(input)?;
123  let (input, _) = define_operator(input)?;
124  let (input, expression) = label!(expression, msg2)(input)?;
125  let mutable = match mutable {
126    Some(_) => true,
127    None => false,
128  };
129  Ok((input, VariableDefine{mutable, var, expression}))
130}
131
132// variable_assign := slice_ref, !define_operator, assign_operator, expression ;
133pub fn variable_assign(input: ParseString) -> ParseResult<VariableAssign> {
134  let msg1 = "Expects spaces around operator";
135  let msg2 = "Expects expression";
136  let (input, target) = slice_ref(input)?;
137  let (input, _) = labelr!(null(is_not(define_operator)), skip_nil, msg1)(input)?;
138  let (input, _) = assign_operator(input)?;
139  let (input, expression) = label!(expression, msg2)(input)?;
140  Ok((input, VariableAssign{target,expression}))
141}
142
143// op_assign := slice_ref, !define-operator, op_assign_operator, expression ;
144pub fn op_assign(input: ParseString) -> ParseResult<OpAssign> {
145  let msg1 = "Expects spaces around operator";
146  let msg2 = "Expects expression";
147  let (input, target) = slice_ref(input)?;
148  let (input, _) = labelr!(null(is_not(define_operator)), skip_nil, msg1)(input)?;
149  let (input, op) = op_assign_operator(input)?;
150  let (input, expression) = label!(expression, msg2)(input)?;
151  Ok((input, OpAssign{target,op,expression}))
152}
153
154// parser for the second line of the output table, generate the 
155// var name if there is one.
156
157// split_operator := ">-" ;
158/*pub fn split_operator(input: ParseString) -> ParseResult<ParserNode> {
159  let (input, _) = tag(">-")(input)?;
160  Ok((input, ParserNode::Null))
161}*/
162
163// flatten_operator := "-<" ;
164/*pub fn flatten_operator(input: ParseString) -> ParseResult<ParserNode> {
165  let (input, _) = tag("-<")(input)?;
166  Ok((input, ParserNode::Null))
167}*/
168
169// statement := variable_define | variable_assign | enum_define | fsm_declare | kind_define ;
170pub fn statement(input: ParseString) -> ParseResult<Statement> {
171  match variable_define(input.clone()) {
172    Ok((input, var_def)) => { return Ok((input, Statement::VariableDefine(var_def))); },
173    //Err(Failure(err)) => {return Err(Failure(err))},
174    _ => (),
175  }
176  match variable_assign(input.clone()) {
177    Ok((input, var_asgn)) => { return Ok((input, Statement::VariableAssign(var_asgn))); },
178    //Err(Failure(err)) => {return Err(Failure(err))},
179    _ => (),
180  }
181  match op_assign(input.clone()) {
182    Ok((input, var_asgn)) => { return Ok((input, Statement::OpAssign(var_asgn))); },
183    //Err(Failure(err)) => {return Err(Failure(err))},
184    _ => (),
185  }
186  match enum_define(input.clone()) {
187    Ok((input, enm_def)) => { return Ok((input, Statement::EnumDefine(enm_def))); },
188    //Err(Failure(err)) => {return Err(Failure(err))},
189    _ => (),
190  }
191  match fsm_declare(input.clone()) {
192    Ok((input, var_def)) => { return Ok((input, Statement::FsmDeclare(var_def))); },
193    //Err(Failure(err)) => {return Err(Failure(err))},
194    _ => (),
195  }
196  match kind_define(input.clone()) {
197    Ok((input, knd_def)) => { return Ok((input, Statement::KindDefine(knd_def))); },
198    Err(err) => { return Err(err); },
199  }
200}
201
202// enum_define := "<", identifier, ">", define_operator, list1(enum_separator, enum_variant);
203pub fn enum_define(input: ParseString) -> ParseResult<EnumDefine> {
204  let (input, _) = left_angle(input)?;
205  let (input, name) = identifier(input)?;
206  let (input, _) = right_angle(input)?;
207  let (input, _) = define_operator(input)?;
208  let (input, variants) = separated_list1(enum_separator, enum_variant)(input)?;
209  Ok((input, EnumDefine{name, variants}))
210}
211
212// enum_variant := grave?, identifier, enum_variant_kind? ;
213pub fn enum_variant(input: ParseString) -> ParseResult<EnumVariant> {
214  let (input, _) = opt(grave)(input)?;
215  let (input, name) = identifier(input)?;
216  let (input, value) = opt(enum_variant_kind)(input)?;
217  Ok((input, EnumVariant{name, value}))
218}
219
220// enum_variant_kind := "(", kind_annotation, ")" ;
221pub fn enum_variant_kind(input: ParseString) -> ParseResult<KindAnnotation> {
222  let (input, _) = left_parenthesis(input)?;
223  let (input, annotation) = kind_annotation(input)?;
224  let (input, _) = right_parenthesis(input)?;
225  Ok((input, annotation))
226}
227
228// kind_define := "<", identifier, ">", define_operator, kind_annotation ;
229pub fn kind_define(input: ParseString) -> ParseResult<KindDefine> {
230  let (input, _) = left_angle(input)?;
231  let (input, name) = identifier(input)?;
232  let (input, _) = right_angle(input)?;
233  let (input, _) = define_operator(input)?;
234  let (input, knd) = kind_annotation(input)?;
235  Ok((input, KindDefine{name,kind:knd}))
236}
237
238
239  
240
mech_syntax/statements.rs

mech_syntax/
statements.rs
