1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
use glicol_parser::*;
use pest::Parser;
use pest::error::ErrorVariant;
// use lcs_diff::*;
// fn main() {
// let a = [1, 3, 5];
// let b = [3, 4, 5];
// // println!("result {:?}", diff(&a, &b));
// let result = diff(&a, &b);
// for r in result {
// println!("result {:?}", r);
// }
// }
fn main() {
let mut block = match GlicolParser::parse(Rule::block, r#"out: sin 440 >> mul 0.1 >> add 0.1; b: seq 60 _60 >> sp \808;"#) {
Ok(v) => v,
Err(e) => {
// println!("in location: {:?}; line_col: {:?}", e.location, e.line_col);
match e.variant {
ErrorVariant::ParsingError{ positives, negatives } => {
if positives.len() != 0 {
print!("\n\nexpecting ");
for possible in positives { print!("{:?} ", possible) }
print!("\n\n");
}
if negatives.len() != 0 {
print!("\n\nunexpected element: ");
for possible in negatives { print!("{:?} ", possible) }
print!("\n\n");
}
panic!();
}
_ => {panic!("unknonw parsing error")}
}
}
};
let lines = block.next().unwrap(); // this can be a comment though, but we call it a line
let mut ast = std::collections::HashMap::new();
for line in lines.into_inner() {
match line.as_rule() {
Rule::line => {
println!("each line {:?}", line.as_str());
let mut key = "";
let mut chain_node_names = vec![];
let mut chain_paras = vec![];
for line_component in line.into_inner() {
match line_component.as_rule() {
Rule::reference => {
println!("ref {:?}", line_component.as_str());
key = line_component.as_str();
},
Rule::chain => {
println!("chain {:?}", line_component.as_str());
let chain = line_component;
for node_pair in chain.into_inner() {
let node = node_pair.into_inner().next().unwrap();
match node.as_rule() {
Rule::sin => {
println!("node {:?}", node.as_str()); //"sin 440"
let paras = node.into_inner().next().unwrap();
println!("paras {:?}", paras.as_str());//"440"
chain_node_names.push("sin");
chain_paras.push(paras.as_str());
},
Rule::mul => {
println!("node {:?}", node.as_str());
let paras = node.into_inner().next().unwrap();
println!("paras {:?}", paras.as_str());
chain_node_names.push("mul");
chain_paras.push(paras.as_str());
},
Rule::add => {
println!("node {:?}", node.as_str());
let paras = node.into_inner().next().unwrap();
println!("paras {:?}", paras.as_str());
chain_node_names.push("add");
chain_paras.push(paras.as_str());
},
Rule::seq => {
println!("node {:?}", node.as_str());
let paras = node.into_inner().next().unwrap();
println!("paras {:?}", paras.as_str());
chain_node_names.push("seq");
chain_paras.push(paras.as_str());
},
Rule::sp => {
println!("node {:?}", node.as_str());
let paras = node.into_inner().next().unwrap();
println!("paras {:?}", paras.as_str());
chain_node_names.push("sp");
chain_paras.push(paras.as_str());
},
_ => {}
}
}
// println!("chain.into_inner(); {:?}", chain.into_inner());
},
_ => {}
}
}
ast.insert(key, (chain_node_names, chain_paras));
},
_ => {},
};
}
println!("ast {:?}", ast);
}