avalog/
parsing.rs

1use crate::*;
2
3use piston_meta::{Convert, Range};
4use std::path::Path;
5
6fn parse_rule<T: Symbol>(
7    node: &str,
8    mut convert: Convert,
9    ignored: &mut Vec<Range>
10) -> Result<(Range, Expr<T>), ()> {
11    let start = convert;
12    let start_range = convert.start_node(node)?;
13    convert.update(start_range);
14
15    let mut res: Option<Expr<T>> = None;
16    let mut args: Vec<Expr<T>> = vec![];
17    loop {
18        if let Ok(range) = convert.end_node(node) {
19            convert.update(range);
20            break;
21        } else if let Ok((range, v)) = parse_expr("res", convert, ignored) {
22            convert.update(range);
23            res = Some(v);
24        } else if let Ok((range, v)) = parse_expr("arg", convert, ignored) {
25            convert.update(range);
26            args.push(v);
27        } else {
28            let range = convert.ignore();
29            convert.update(range);
30            ignored.push(range);
31        }
32    }
33
34    let res = res.ok_or(())?;
35    Ok((convert.subtract(start), Expr::Rule(Box::new(res), args)))
36}
37
38fn parse_inner<T: Symbol>(
39    node: &str,
40    mut convert: Convert,
41    ignored: &mut Vec<Range>
42) -> Result<(Range, Expr<T>), ()> {
43    let start = convert;
44    let start_range = convert.start_node(node)?;
45    convert.update(start_range);
46
47    let mut arg: Option<Expr<T>> = None;
48    loop {
49        if let Ok(range) = convert.end_node(node) {
50            convert.update(range);
51            break;
52        } else if let Ok((range, v)) = parse_expr("arg", convert, ignored) {
53            convert.update(range);
54            arg = Some(v);
55        } else {
56            let range = convert.ignore();
57            convert.update(range);
58            ignored.push(range);
59        }
60    }
61
62    let arg = arg.ok_or(())?;
63    Ok((convert.subtract(start), Expr::Inner(Box::new(arg))))
64}
65
66fn parse_app<T: Symbol>(
67    node: &str,
68    mut convert: Convert,
69    ignored: &mut Vec<Range>
70) -> Result<(Range, Expr<T>), ()> {
71    let start = convert;
72    let start_range = convert.start_node(node)?;
73    convert.update(start_range);
74
75    let mut f: Option<Expr<T>> = None;
76    let mut arg: Vec<Expr<T>> = vec![];
77    loop {
78        if let Ok(range) = convert.end_node(node) {
79            convert.update(range);
80            break;
81        } else if let Ok((range, v)) = convert.meta_string("f") {
82            convert.update(range);
83            if T::is_var(&v) {
84                f = Some(Expr::Var(v));
85            } else {
86                f = Some(Expr::Sym(v.into()));
87            }
88        } else if let Ok((range, v)) = parse_expr("arg", convert, ignored) {
89            convert.update(range);
90            arg.push(v);
91        } else if let Ok((range, v)) = convert.meta_bool("tail") {
92            convert.update(range);
93            if v {arg.push(Tail)};
94        } else if let Ok((range, v)) = convert.meta_string("tail_sym") {
95            convert.update(range);
96            arg.push(TailVar(v.into()));
97        } else {
98            let range = convert.ignore();
99            convert.update(range);
100            ignored.push(range);
101        }
102    }
103
104    let mut expr = f.ok_or(())?;
105    for a in &arg {
106        expr = app(expr, a.clone());
107    }
108
109    Ok((convert.subtract(start), expr))
110}
111
112fn parse_ava<T: Symbol>(
113    node: &str,
114    mut convert: Convert,
115    ignored: &mut Vec<Range>
116) -> Result<(Range, Expr<T>), ()> {
117    let start = convert;
118    let start_range = convert.start_node(node)?;
119    convert.update(start_range);
120
121    let mut avatar: Option<Expr<T>> = None;
122    let mut core: Option<Expr<T>> = None;
123    loop {
124        if let Ok(range) = convert.end_node(node) {
125            convert.update(range);
126            break;
127        } else if let Ok((range, v)) = convert.meta_string("avatar") {
128            convert.update(range);
129            if T::is_var(&v) {
130                avatar = Some(Expr::Var(v));
131            } else {
132                avatar = Some(Expr::Sym(v.into()));
133            }
134        } else if let Ok((range, v)) = parse_expr("core", convert, ignored) {
135            convert.update(range);
136            core = Some(v);
137        } else {
138            let range = convert.ignore();
139            convert.update(range);
140            ignored.push(range);
141        }
142    }
143
144    let avatar = avatar.ok_or(())?;
145    let core = core.ok_or(())?;
146    Ok((convert.subtract(start), Expr::Ava(
147        Box::new(avatar),
148        Box::new(core)
149    )))
150}
151
152fn parse_uniq<T: Symbol>(
153    node: &str,
154    mut convert: Convert,
155    ignored: &mut Vec<Range>
156) -> Result<(Range, Expr<T>), ()> {
157    let start = convert;
158    let start_range = convert.start_node(node)?;
159    convert.update(start_range);
160
161    let mut arg: Option<Expr<T>> = None;
162    loop {
163        if let Ok(range) = convert.end_node(node) {
164            convert.update(range);
165            break;
166        } else if let Ok((range, v)) = parse_expr("arg", convert, ignored) {
167            convert.update(range);
168            arg = Some(Expr::UniqAva(Box::new(v)));
169        } else {
170            let range = convert.ignore();
171            convert.update(range);
172            ignored.push(range);
173        }
174    }
175
176    let arg = arg.ok_or(())?;
177    Ok((convert.subtract(start), arg))
178}
179
180/// Parses symbol or variable.
181///
182/// Converts to variable automatically when starting with upper case.
183fn parse_sym_or_var<T: Symbol>(
184    node: &str,
185    mut convert: Convert,
186    ignored: &mut Vec<Range>
187) -> Result<(Range, Expr<T>), ()> {
188    let start = convert;
189    let start_range = convert.start_node(node)?;
190    convert.update(start_range);
191
192    let mut val: Option<Expr<T>> = None;
193    loop {
194        if let Ok(range) = convert.end_node(node) {
195            convert.update(range);
196            break;
197        } else if let Ok((range, v)) = convert.meta_string("val") {
198            convert.update(range);
199            if T::is_var(&v) {
200                val = Some(Expr::Var(v));
201            } else {
202                val = Some(Expr::Sym(v.into()));
203            }
204        } else if let Ok((range, v)) = convert.meta_string("str_val") {
205            convert.update(range);
206            let v = Arc::new(format!("{:?}", v));
207            if T::is_var(&v) {
208                val = Some(Expr::Var(v));
209            } else {
210                val = Some(Expr::Sym(v.into()));
211            }
212        } else {
213            let range = convert.ignore();
214            convert.update(range);
215            ignored.push(range);
216        }
217    }
218
219    let val = val.ok_or(())?;
220    Ok((convert.subtract(start), val))
221}
222
223fn parse_has<T: Symbol>(
224    node: &str,
225    mut convert: Convert,
226    ignored: &mut Vec<Range>
227) -> Result<(Range, Expr<T>), ()> {
228    let start = convert;
229    let start_range = convert.start_node(node)?;
230    convert.update(start_range);
231
232    let mut f: Option<Expr<T>> = None;
233    let mut arg: Option<Expr<T>> = None;
234    let mut res: Option<Expr<T>> = None;
235    loop {
236        if let Ok(range) = convert.end_node(node) {
237            convert.update(range);
238            break;
239        } else if let Ok((range, val)) = parse_expr("f", convert, ignored) {
240            convert.update(range);
241            f = Some(val);
242        } else if let Ok((range, val)) = parse_expr("arg", convert, ignored) {
243            convert.update(range);
244            arg = Some(val);
245        } else if let Ok((range, v)) = parse_expr("res", convert, ignored) {
246            convert.update(range);
247            res = Some(v);
248        } else {
249            let range = convert.ignore();
250            convert.update(range);
251            ignored.push(range);
252        }
253    }
254
255    let f = f.ok_or(())?;
256    let arg = arg.ok_or(())?;
257    let res = res.ok_or(())?;
258    Ok((convert.subtract(start), Expr::Has(
259        Box::new(Expr::App(Box::new(f), Box::new(arg))),
260        Box::new(res)
261    )))
262}
263
264fn parse_eq<T: Symbol>(
265    node: &str,
266    mut convert: Convert,
267    ignored: &mut Vec<Range>
268) -> Result<(Range, Expr<T>), ()> {
269    let start = convert;
270    let start_range = convert.start_node(node)?;
271    convert.update(start_range);
272
273    let mut f: Option<Expr<T>> = None;
274    let mut arg: Option<Expr<T>> = None;
275    let mut res: Option<Expr<T>> = None;
276    loop {
277        if let Ok(range) = convert.end_node(node) {
278            convert.update(range);
279            break;
280        } else if let Ok((range, val)) = parse_expr("f", convert, ignored) {
281            convert.update(range);
282            f = Some(val);
283        } else if let Ok((range, val)) = parse_expr("arg", convert, ignored) {
284            convert.update(range);
285            arg = Some(val);
286        } else if let Ok((range, v)) = parse_expr("res", convert, ignored) {
287            convert.update(range);
288            res = Some(v);
289        } else {
290            let range = convert.ignore();
291            convert.update(range);
292            ignored.push(range);
293        }
294    }
295
296    let f = f.ok_or(())?;
297    let arg = arg.ok_or(())?;
298    let res = res.ok_or(())?;
299    Ok((convert.subtract(start), Expr::Eq(
300        Box::new(Expr::App(Box::new(f), Box::new(arg))),
301        Box::new(res)
302    )))
303}
304
305fn parse_neq<T: Symbol>(
306    node: &str,
307    mut convert: Convert,
308    ignored: &mut Vec<Range>
309) -> Result<(Range, Expr<T>), ()> {
310    let start = convert;
311    let start_range = convert.start_node(node)?;
312    convert.update(start_range);
313
314    let mut left: Option<Expr<T>> = None;
315    let mut right: Option<Expr<T>> = None;
316    loop {
317        if let Ok(range) = convert.end_node(node) {
318            convert.update(range);
319            break;
320        } else if let Ok((range, val)) = parse_expr("left", convert, ignored) {
321            convert.update(range);
322            left = Some(val);
323        } else if let Ok((range, val)) = parse_expr("right", convert, ignored) {
324            convert.update(range);
325            right = Some(val);
326        } else {
327            let range = convert.ignore();
328            convert.update(range);
329            ignored.push(range);
330        }
331    }
332
333    let left = left.ok_or(())?;
334    let right = right.ok_or(())?;
335    Ok((convert.subtract(start), Expr::Neq(
336        Box::new(left),
337        Box::new(right)
338    )))
339}
340
341fn parse_role_of<T: Symbol>(
342    node: &str,
343    mut convert: Convert,
344    ignored: &mut Vec<Range>
345) -> Result<(Range, Expr<T>), ()> {
346    let start = convert;
347    let start_range = convert.start_node(node)?;
348    convert.update(start_range);
349
350    let mut arg: Option<Expr<T>> = None;
351    let mut role: Option<Expr<T>> = None;
352    loop {
353        if let Ok(range) = convert.end_node(node) {
354            convert.update(range);
355            break;
356        } else if let Ok((range, val)) = parse_expr("arg", convert, ignored) {
357            convert.update(range);
358            arg = Some(val);
359        } else if let Ok((range, v)) = parse_expr("role", convert, ignored) {
360            convert.update(range);
361            role = Some(v);
362        } else {
363            let range = convert.ignore();
364            convert.update(range);
365            ignored.push(range);
366        }
367    }
368
369    let arg = arg.ok_or(())?;
370    let role = role.ok_or(())?;
371    Ok((convert.subtract(start), Expr::RoleOf(
372        Box::new(arg),
373        Box::new(role)
374    )))
375}
376
377fn parse_amb_role<T: Symbol>(
378    node: &str,
379    mut convert: Convert,
380    ignored: &mut Vec<Range>
381) -> Result<(Range, Expr<T>), ()> {
382    let start = convert;
383    let start_range = convert.start_node(node)?;
384    convert.update(start_range);
385
386    let mut a: Option<Expr<T>> = None;
387    let mut b1: Option<Expr<T>> = None;
388    let mut b2: Option<Expr<T>> = None;
389    loop {
390        if let Ok(range) = convert.end_node(node) {
391            convert.update(range);
392            break;
393        } else if let Ok((range, val)) = parse_expr("a", convert, ignored) {
394            convert.update(range);
395            a = Some(val);
396        } else if let Ok((range, val)) = parse_expr("b1", convert, ignored) {
397            convert.update(range);
398            b1 = Some(val);
399        } else if let Ok((range, val)) = parse_expr("b2", convert, ignored) {
400            convert.update(range);
401            b2 = Some(val);
402        } else {
403            let range = convert.ignore();
404            convert.update(range);
405            ignored.push(range);
406        }
407    }
408
409    let a = a.ok_or(())?;
410    let b1 = b1.ok_or(())?;
411    let b2 = b2.ok_or(())?;
412    Ok((convert.subtract(start), ambiguous_role(a, b1, b2)))
413}
414
415fn parse_amb_rel<T: Symbol>(
416    node: &str,
417    mut convert: Convert,
418    ignored: &mut Vec<Range>
419) -> Result<(Range, Expr<T>), ()> {
420    let start = convert;
421    let start_range = convert.start_node(node)?;
422    convert.update(start_range);
423
424    let mut a: Option<Expr<T>> = None;
425    let mut b1: Option<Expr<T>> = None;
426    let mut b2: Option<Expr<T>> = None;
427    loop {
428        if let Ok(range) = convert.end_node(node) {
429            convert.update(range);
430            break;
431        } else if let Ok((range, val)) = parse_expr("a", convert, ignored) {
432            convert.update(range);
433            a = Some(val);
434        } else if let Ok((range, val)) = parse_expr("b1", convert, ignored) {
435            convert.update(range);
436            b1 = Some(val);
437        } else if let Ok((range, val)) = parse_expr("b2", convert, ignored) {
438            convert.update(range);
439            b2 = Some(val);
440        } else {
441            let range = convert.ignore();
442            convert.update(range);
443            ignored.push(range);
444        }
445    }
446
447    let a = a.ok_or(())?;
448    let b1 = b1.ok_or(())?;
449    let b2 = b2.ok_or(())?;
450    Ok((convert.subtract(start), ambiguous_rel(a, b1, b2)))
451}
452
453fn parse_rel<T: Symbol>(
454    node: &str,
455    mut convert: Convert,
456    ignored: &mut Vec<Range>
457) -> Result<(Range, Expr<T>), ()> {
458    let start = convert;
459    let start_range = convert.start_node(node)?;
460    convert.update(start_range);
461
462    let mut a: Option<Expr<T>> = None;
463    let mut b: Option<Expr<T>> = None;
464    loop {
465        if let Ok(range) = convert.end_node(node) {
466            convert.update(range);
467            break;
468        } else if let Ok((range, val)) = parse_expr("a", convert, ignored) {
469            convert.update(range);
470            a = Some(val);
471        } else if let Ok((range, val)) = parse_expr("b", convert, ignored) {
472            convert.update(range);
473            b = Some(val);
474        } else {
475            let range = convert.ignore();
476            convert.update(range);
477            ignored.push(range);
478        }
479    }
480
481    let a = a.ok_or(())?;
482    let b = b.ok_or(())?;
483    Ok((convert.subtract(start), Expr::Rel(
484        Box::new(a),
485        Box::new(b)
486    )))
487}
488
489fn parse_expr<T: Symbol>(
490    node: &str,
491    mut convert: Convert,
492    ignored: &mut Vec<Range>
493) -> Result<(Range, Expr<T>), ()> {
494    let start = convert;
495    let start_range = convert.start_node(node)?;
496    convert.update(start_range);
497
498    let mut expr: Option<Expr<T>> = None;
499    loop {
500        if let Ok(range) = convert.end_node(node) {
501            convert.update(range);
502            break;
503        } else if let Ok((range, val)) = parse_role_of("role_of", convert, ignored) {
504            convert.update(range);
505            expr = Some(val);
506        } else if let Ok((range, val)) = parse_rel("rel", convert, ignored) {
507            convert.update(range);
508            expr = Some(val);
509        } else if let Ok((range, val)) = parse_sym_or_var("sym", convert, ignored) {
510            convert.update(range);
511            expr = Some(val);
512        } else if let Ok((range, val)) = parse_uniq("uniq", convert, ignored) {
513            convert.update(range);
514            expr = Some(val);
515        } else if let Ok((range, val)) = parse_ava("ava", convert, ignored) {
516            convert.update(range);
517            expr = Some(val);
518        } else if let Ok((range, val)) = parse_inner("inner", convert, ignored) {
519            convert.update(range);
520            expr = Some(val);
521        } else if let Ok((range, val)) = parse_app("app", convert, ignored) {
522            convert.update(range);
523            expr = Some(val);
524        } else if let Ok((range, val)) = parse_eq("eq", convert, ignored) {
525            convert.update(range);
526            expr = Some(val);
527        } else if let Ok((range, val)) = parse_neq("neq", convert, ignored) {
528            convert.update(range);
529            expr = Some(val);
530        } else if let Ok((range, val)) = parse_has("has", convert, ignored) {
531            convert.update(range);
532            expr = Some(val);
533        } else if let Ok((range, val)) = parse_amb_rel("amb_rel", convert, ignored) {
534            convert.update(range);
535            expr = Some(val);
536        } else if let Ok((range, val)) = parse_amb_role("amb_role", convert, ignored) {
537            convert.update(range);
538            expr = Some(val);
539        } else if let Ok((range, val)) = parse_rule("rule", convert, ignored) {
540            convert.update(range);
541            expr = Some(val);
542        } else if let Ok((range, val)) = convert.meta_bool("amb") {
543            convert.update(range);
544            expr = Some(Ambiguity(val));
545        } else {
546            let range = convert.ignore();
547            convert.update(range);
548            ignored.push(range);
549        }
550    }
551
552    let expr = expr.ok_or(())?;
553    Ok((convert.subtract(start), expr))
554}
555
556fn parse_data<T: Symbol>(
557    node: &str,
558    mut convert: Convert,
559    ignored: &mut Vec<Range>,
560    parent: &Path
561) -> Result<(Range, Vec<Expr<T>>), ()> {
562    let start = convert;
563    let start_range = convert.start_node(node)?;
564    convert.update(start_range);
565
566    let mut res: Vec<Expr<T>> = vec![];
567    let mut eval: Option<T> = None;
568    let mut role: Option<Expr<T>> = None;
569    loop {
570        if let Ok(range) = convert.end_node(node) {
571            convert.update(range);
572            break;
573        } else if let Ok((range, val)) = parse_expr("expr", convert, ignored) {
574            convert.update(range);
575            let val = if let Some(eval) = eval.as_ref() {
576                let top = true;
577                val.eval_lift(eval, top)
578            } else {
579                val
580            };
581            res.push(val);
582        } else if let Ok((range, val)) = convert.meta_string("eval") {
583            convert.update(range);
584            eval = Some(val.into());
585        } else if let Ok((range, val)) = convert.meta_bool("no_eval") {
586            convert.update(range);
587            if val {eval = None};
588        } else if let Ok((range, val)) = convert.meta_string("import") {
589            convert.update(range);
590            match parse(parent.join(&**val)) {
591                Ok(facts) => res.extend(facts),
592                Err(err) => println!("ERROR:\n{}", err),
593            }
594        } else if let Ok((range, val)) = parse_expr("role", convert, ignored) {
595            convert.update(range);
596            role = Some(val);
597        } else if let Ok((range, val)) = parse_expr("arg", convert, ignored) {
598            convert.update(range);
599            if let Some(role) = role.as_ref() {
600                res.push(RoleOf(Box::new(val), Box::new(role.clone().into())));
601            }
602        } else {
603            let range = convert.ignore();
604            convert.update(range);
605            ignored.push(range);
606        }
607    }
608
609    Ok((convert.subtract(start), res))
610}
611
612/// Parses a string.
613pub fn parse_str<T: Symbol>(
614    data: &str,
615    parent: &Path
616) -> Result<Vec<Expr<T>>, String> {
617    use piston_meta::{parse_errstr, syntax_errstr};
618
619    let syntax_src = include_str!("../assets/syntax.txt");
620    let syntax = syntax_errstr(syntax_src)?;
621
622    let mut meta_data = vec![];
623    parse_errstr(&syntax, &data, &mut meta_data)?;
624
625    // piston_meta::json::print(&meta_data);
626
627    let convert = Convert::new(&meta_data);
628    let mut ignored = vec![];
629    match parse_data("data", convert, &mut ignored, parent) {
630        Err(()) => Err("Could not convert meta data".into()),
631        Ok((_, expr)) => Ok(expr),
632    }
633}
634
635/// Helps specifying the parse data type.
636pub type ParseData<T = Arc<String>> = Vec<Expr<T>>;
637/// Helps specifying the type of the parsing result.
638pub type ParseResult<T = Arc<String>> = Result<ParseData<T>, String>;
639
640/// Parses a source file.
641pub fn parse<P, T>(source: P) -> ParseResult<T>
642    where P: AsRef<Path>, T: Symbol
643{
644    use std::fs::File;
645    use std::io::Read;
646
647    let source = source.as_ref();
648    let mut data_file = File::open(source).map_err(|err|
649        format!("Could not open `{:?}`, {}", source, err))?;
650    let mut data = String::new();
651    let parent = if let Some(dir) = source.parent() {
652        dir
653    } else {
654        return Err("Could not get parent directory of file".into());
655    };
656    data_file.read_to_string(&mut data).unwrap();
657    parse_str(&data, &parent)
658}
avalog/parsing.rs

avalog/
parsing.rs
