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, _) = 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// statement := variable_define | variable_assign | enum_define | fsm_declare | kind_define ;
145pub fn statement(input: ParseString) -> ParseResult<Statement> {
146  match variable_define(input.clone()) {
147    Ok((input, var_def)) => { return Ok((input, Statement::VariableDefine(var_def))); },
148    //Err(Failure(err)) => {return Err(Failure(err))},
149    _ => (),
150  }
151  match variable_assign(input.clone()) {
152    Ok((input, var_asgn)) => { return Ok((input, Statement::VariableAssign(var_asgn))); },
153    //Err(Failure(err)) => {return Err(Failure(err))},
154    _ => (),
155  }
156  match op_assign(input.clone()) {
157    Ok((input, var_asgn)) => { return Ok((input, Statement::OpAssign(var_asgn))); },
158    //Err(Failure(err)) => {return Err(Failure(err))},
159    _ => (),
160  }
161  match enum_define(input.clone()) {
162    Ok((input, enm_def)) => { return Ok((input, Statement::EnumDefine(enm_def))); },
163    //Err(Failure(err)) => {return Err(Failure(err))},
164    _ => (),
165  }
166  match fsm_declare(input.clone()) {
167    Ok((input, var_def)) => { return Ok((input, Statement::FsmDeclare(var_def))); },
168    //Err(Failure(err)) => {return Err(Failure(err))},
169    _ => (),
170  }
171  match kind_define(input.clone()) {
172    Ok((input, knd_def)) => { return Ok((input, Statement::KindDefine(knd_def))); },
173    Err(err) => { return Err(err); },
174  }
175}
176
177// enum_define := "<", identifier, ">", define_operator, list1(enum_separator, enum_variant);
178pub fn enum_define(input: ParseString) -> ParseResult<EnumDefine> {
179  let (input, _) = left_angle(input)?;
180  let (input, name) = identifier(input)?;
181  let (input, _) = right_angle(input)?;
182  let (input, _) = define_operator(input)?;
183  let (input, variants) = separated_list1(enum_separator, enum_variant)(input)?;
184  Ok((input, EnumDefine{name, variants}))
185}
186
187// enum_variant := grave?, identifier, enum_variant_kind? ;
188pub fn enum_variant(input: ParseString) -> ParseResult<EnumVariant> {
189  let (input, _) = opt(grave)(input)?;
190  let (input, name) = identifier(input)?;
191  let (input, value) = opt(enum_variant_kind)(input)?;
192  Ok((input, EnumVariant{name, value}))
193}
194
195// enum_variant_kind := "(", kind_annotation, ")" ;
196pub fn enum_variant_kind(input: ParseString) -> ParseResult<KindAnnotation> {
197  let (input, _) = left_parenthesis(input)?;
198  let (input, annotation) = kind_annotation(input)?;
199  let (input, _) = right_parenthesis(input)?;
200  Ok((input, annotation))
201}
202
203// kind_define := "<", identifier, ">", define_operator, kind_annotation ;
204pub fn kind_define(input: ParseString) -> ParseResult<KindDefine> {
205  let (input, _) = left_angle(input)?;
206  let (input, name) = identifier(input)?;
207  let (input, _) = right_angle(input)?;
208  let (input, _) = define_operator(input)?;
209  let (input, knd) = kind_annotation(input)?;
210  Ok((input, KindDefine{name,kind:knd}))
211}
212
213
214  
215
mech_syntax/statements.rs

mech_syntax/
statements.rs
