marpa 0.3.0

Safe bindings to the libmarpa parsing engine
Documentation 
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

use crate::thin::tree;
use crate::thin::{Grammar, Result, Step, Tree};
use libmarpa_sys::*;

pub struct Value {
    internal: Marpa_Value,
    // we need to keep a reference to this accessible
    // in order to read error codes.
    grammar: Grammar,
}

impl Value {
    pub fn new(t: Tree) -> Result<Value> {
        let t_internal = tree::internal(&t);
        let grammar = tree::grammar(&t);
        match unsafe { marpa_v_new(t_internal) } {
            n if n.is_null() => grammar.error_or("error creating value"),
            v => Ok(Value { internal: v, grammar }),
        }
    }
}

#[allow(dead_code)]
pub fn internal(value: &Value) -> Marpa_Value {
    value.internal
}

#[allow(dead_code)]
pub fn grammar(value: &Value) -> Grammar {
    value.grammar.clone()
}

impl Clone for Value {
    fn clone(&self) -> Value {
        unsafe { marpa_v_ref(self.internal) };
        Value {
            internal: self.internal,
            grammar: self.grammar.clone(),
        }
    }
}

impl Drop for Value {
    fn drop(&mut self) {
        unsafe { marpa_v_unref(self.internal) };
    }
}

impl Iterator for Value {
    type Item = Step;

    fn next(&mut self) -> Option<Self::Item> {
        unsafe {
            match marpa_v_step(self.internal) as _ {
                MARPA_STEP_INITIAL => self.next(),
                MARPA_STEP_INACTIVE => None,

                MARPA_STEP_NULLING_SYMBOL => Some(Step::NullingSymbol((*self.internal).t_token_id, (*self.internal).t_result)),

                MARPA_STEP_RULE => Some(Step::Rule(
                    (*self.internal).t_rule_id,
                    (*self.internal).t_result,
                    (*self.internal).t_arg_n,
                )),

                MARPA_STEP_TOKEN => Some(Step::Token(
                    (*self.internal).t_token_id,
                    (*self.internal).t_result,
                    (*self.internal).t_token_value,
                )),

                // the only thing left are the internal-only and invalid types
                _ => None,
            }
        }
    }
}