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

mech_syntax/
statements.rs
