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 | op-assign | enum-define | tuple-destructure | kind-define ;
156pub fn statement(input: ParseString) -> ParseResult<Statement> {
157  let parsers: Vec<(&'static str,Box<dyn Fn(ParseString) -> ParseResult<Statement>>)> = vec![
158    ("variable_define", Box::new(|i| variable_define(i).map(|(i, v)| (i, Statement::VariableDefine(v))))),
159    ("variable_assign", Box::new(|i| variable_assign(i).map(|(i, v)| (i, Statement::VariableAssign(v))))),
160    ("op_assign", Box::new(|i| op_assign(i).map(|(i, v)| (i, Statement::OpAssign(v))))),
161    ("enum_define", Box::new(|i| enum_define(i).map(|(i, v)| (i, Statement::EnumDefine(v))))),
162    ("tuple_destructure", Box::new(|i| tuple_destructure(i).map(|(i, v)| (i, Statement::TupleDestructure(v))))),
163    ("kind_define", Box::new(|i| kind_define(i).map(|(i, v)| (i, Statement::KindDefine(v))))),
164  ];
165  alt_best(input, &parsers)
166}
167
168// enum-define := "<", identifier, ">", define-operator, list1(enum-separator, enum-variant);
169pub fn enum_define(input: ParseString) -> ParseResult<EnumDefine> {
170  let (input, _) = left_angle(input)?;
171  let (input, name) = identifier(input)?;
172  let (input, _) = right_angle(input)?;
173  let (input, _) = define_operator(input)?;
174  let (input, variants) = separated_list1(enum_separator, enum_variant)(input)?;
175  Ok((input, EnumDefine{name, variants}))
176}
177
178// enum-variant := grave?, identifier, enum-variant-kind? ;
179pub fn enum_variant(input: ParseString) -> ParseResult<EnumVariant> {
180  let (input, _) = opt(grave)(input)?;
181  let (input, name) = identifier(input)?;
182  let (input, value) = opt(enum_variant_kind)(input)?;
183  Ok((input, EnumVariant{name, value}))
184}
185
186// enum-variant-kind := "(", kind-annotation, ")" ;
187pub fn enum_variant_kind(input: ParseString) -> ParseResult<KindAnnotation> {
188  let (input, _) = left_parenthesis(input)?;
189  let (input, annotation) = kind_annotation(input)?;
190  let (input, _) = right_parenthesis(input)?;
191  Ok((input, annotation))
192}
193
194// kind-define := "<", identifier, ">", define-operator, kind-annotation ;
195pub fn kind_define(input: ParseString) -> ParseResult<KindDefine> {
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, knd) = kind_annotation(input)?;
201  Ok((input, KindDefine{name,kind:knd}))
202}
mech_syntax/statements.rs

mech_syntax/
statements.rs
