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// op_assign_operator := add_assign_operator | sub_assign_operator | mul_assign_operator | div_assign_operator | exp_assign_operator ;
39pub fn op_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
40  alt((add_assign_operator, sub_assign_operator, mul_assign_operator, div_assign_operator, exp_assign_operator))(input)
41}
42
43// add_assign_operator := "+=" ;
44pub fn add_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
45  let (input, _) = whitespace0(input)?;
46  let (input, _) = tag("+=")(input)?;
47  let (input, _) = whitespace0(input)?;
48  Ok((input, OpAssignOp::Add))
49}
50
51// sub_assign_operator := "-=" ;
52pub fn sub_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::Sub))
57}
58
59// mul_assign_operator := "*=" ;
60pub fn mul_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::Mul))
65}
66// div_assign_operator := "/=" ;
67pub fn div_assign_operator(input: ParseString) -> ParseResult<OpAssignOp> {
68  let (input, _) = whitespace0(input)?;
69  let (input, _) = tag("/=")(input)?;
70  let (input, _) = whitespace0(input)?;
71  Ok((input, OpAssignOp::Div))
72}
73
74// exp_assign_operator := "^=" ;
75pub fn exp_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::Exp))
80}
81
82// split_data := (identifier | table), <!stmt_operator>, space*, split_operator, <space+>, <expression> ;
83/*pub fn split_data(input: ParseString) -> ParseResult<ParserNode> {
84  /*let msg1 = "Expects spaces around operator";
85  let msg2 = "Expects expression";
86  let (input, table) = alt((identifier, table))(input)?;
87  let (input, _) = labelr!(null(is_not(stmt_operator)), skip_nil, msg1)(input)?;
88  let (input, _) = many0(space)(input)?;
89  let (input, _) = split_operator(input)?;
90  let (input, _) = labelr!(null(many1(space)), skip_nil, msg1)(input)?;
91  let (input, expression) = label!(expression, msg2)(input)?;*/
92  Ok((input, ParserNode::SplitData{children: vec![]}))
93}*/
94
95// flatten_data := identifier, <!stmt_operator>, space*, flatten_operator, <space+>, <expression> ;
96/*pub fn flatten_data(input: ParseString) -> ParseResult<ParserNode> {
97  /*let msg1 = "Expects spaces around operator";
98  let msg2 = "Expects expression";
99  let (input, table) = identifier(input)?;
100  let (input, _) = labelr!(null(is_not(stmt_operator)), skip_nil, msg1)(input)?;
101  let (input, _) = many0(space)(input)?;
102  let (input, _) = flatten_operator(input)?;
103  let (input, _) = labelr!(null(many1(space)), skip_nil, msg1)(input)?;
104  let (input, expression) = label!(expression, msg2)(input)?;*/
105  Ok((input, ParserNode::FlattenData{children: vec![]}))
106}*/
107
108// variable_define := tilde?, var, !assign_operator, define_operator, expression ;
109pub fn variable_define(input: ParseString) -> ParseResult<VariableDefine> {
110  let msg1 = "Expects spaces around operator";
111  let msg2 = "Expects expression";
112  let (input, mutable) = opt(tilde)(input)?; 
113  let (input, var) = var(input)?;
114  let (input, _) = labelr!(null(is_not(assign_operator)), skip_nil, msg1)(input)?;
115  let (input, _) = define_operator(input)?;
116  let (input, expression) = label!(expression, msg2)(input)?;
117  let mutable = match mutable {
118    Some(_) => true,
119    None => false,
120  };
121  Ok((input, VariableDefine{mutable, var, expression}))
122}
123
124// variable_assign := slice_ref, !define_operator, assign_operator, expression ;
125pub fn variable_assign(input: ParseString) -> ParseResult<VariableAssign> {
126  let msg1 = "Expects spaces around operator";
127  let msg2 = "Expects expression";
128  let (input, target) = slice_ref(input)?;
129  let (input, _) = labelr!(null(is_not(define_operator)), skip_nil, msg1)(input)?;
130  let (input, _) = assign_operator(input)?;
131  let (input, expression) = label!(expression, msg2)(input)?;
132  Ok((input, VariableAssign{target,expression}))
133}
134
135// op_assign := slice_ref, !define-operator, op_assign_operator, expression ;
136pub fn op_assign(input: ParseString) -> ParseResult<OpAssign> {
137  let msg1 = "Expects spaces around operator";
138  let msg2 = "Expects expression";
139  let (input, target) = slice_ref(input)?;
140  let (input, _) = labelr!(null(is_not(define_operator)), skip_nil, msg1)(input)?;
141  let (input, op) = op_assign_operator(input)?;
142  let (input, expression) = label!(expression, msg2)(input)?;
143  Ok((input, OpAssign{target,op,expression}))
144}
145
146// parser for the second line of the output table, generate the 
147// var name if there is one.
148
149// split_operator := ">-" ;
150/*pub fn split_operator(input: ParseString) -> ParseResult<ParserNode> {
151  let (input, _) = tag(">-")(input)?;
152  Ok((input, ParserNode::Null))
153}*/
154
155// flatten_operator := "-<" ;
156/*pub fn flatten_operator(input: ParseString) -> ParseResult<ParserNode> {
157  let (input, _) = tag("-<")(input)?;
158  Ok((input, ParserNode::Null))
159}*/
160
161// statement := variable_define | variable_assign | enum_define | fsm_declare | kind_define ;
162pub fn statement(input: ParseString) -> ParseResult<Statement> {
163  match variable_define(input.clone()) {
164    Ok((input, var_def)) => { return Ok((input, Statement::VariableDefine(var_def))); },
165    //Err(Failure(err)) => {return Err(Failure(err))},
166    _ => (),
167  }
168  match variable_assign(input.clone()) {
169    Ok((input, var_asgn)) => { return Ok((input, Statement::VariableAssign(var_asgn))); },
170    //Err(Failure(err)) => {return Err(Failure(err))},
171    _ => (),
172  }
173  match op_assign(input.clone()) {
174    Ok((input, var_asgn)) => { return Ok((input, Statement::OpAssign(var_asgn))); },
175    //Err(Failure(err)) => {return Err(Failure(err))},
176    _ => (),
177  }
178  match enum_define(input.clone()) {
179    Ok((input, enm_def)) => { return Ok((input, Statement::EnumDefine(enm_def))); },
180    //Err(Failure(err)) => {return Err(Failure(err))},
181    _ => (),
182  }
183  match fsm_declare(input.clone()) {
184    Ok((input, var_def)) => { return Ok((input, Statement::FsmDeclare(var_def))); },
185    //Err(Failure(err)) => {return Err(Failure(err))},
186    _ => (),
187  }
188  match kind_define(input.clone()) {
189    Ok((input, knd_def)) => { return Ok((input, Statement::KindDefine(knd_def))); },
190    Err(err) => { return Err(err); },
191  }
192}
193
194// enum_define := "<", identifier, ">", define_operator, list1(enum_separator, enum_variant);
195pub fn enum_define(input: ParseString) -> ParseResult<EnumDefine> {
196  let (input, _) = left_angle(input)?;
197  let (input, name) = identifier(input)?;
198  let (input, _) = right_angle(input)?;
199  let (input, _) = define_operator(input)?;
200  let (input, variants) = separated_list1(enum_separator, enum_variant)(input)?;
201  Ok((input, EnumDefine{name, variants}))
202}
203
204// enum_variant := grave?, identifier, enum_variant_kind? ;
205pub fn enum_variant(input: ParseString) -> ParseResult<EnumVariant> {
206  let (input, _) = opt(grave)(input)?;
207  let (input, name) = identifier(input)?;
208  let (input, value) = opt(enum_variant_kind)(input)?;
209  Ok((input, EnumVariant{name, value}))
210}
211
212// enum_variant_kind := "(", kind_annotation, ")" ;
213pub fn enum_variant_kind(input: ParseString) -> ParseResult<KindAnnotation> {
214  let (input, _) = left_parenthesis(input)?;
215  let (input, annotation) = kind_annotation(input)?;
216  let (input, _) = right_parenthesis(input)?;
217  Ok((input, annotation))
218}
219
220// kind_define := "<", identifier, ">", define_operator, kind_annotation ;
221pub fn kind_define(input: ParseString) -> ParseResult<KindDefine> {
222  let (input, _) = left_angle(input)?;
223  let (input, name) = identifier(input)?;
224  let (input, _) = right_angle(input)?;
225  let (input, _) = define_operator(input)?;
226  let (input, knd) = kind_annotation(input)?;
227  Ok((input, KindDefine{name,kind:knd}))
228}
229
230
231  
232
mech_syntax/statements.rs

mech_syntax/
statements.rs
