valkyrie-antlr 0.0.1

The hand write parser of valkyrie language
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

use super::*;
use valkyrie_ast::{BooleanNode, NullNode};

impl<'i> Extractor<AtomicContextAll<'i>> for ExpressionType {
    fn take_one(node: &AtomicContextAll<'i>) -> Option<Self> {
        let body: ExpressionType = match node {
            AtomicContextAll::ASpecialContext(s) => {
                let this = s.SPECIAL()?;
                let text = this.get_text();
                let span = Range { start: this.symbol.start as u32, end: this.symbol.stop as u32 };
                match text.as_str() {
                    "true" => BooleanNode { value: true, span }.into(),
                    "false" => BooleanNode { value: false, span }.into(),
                    "null" => NullNode { nil: false, span }.into(),
                    "nil" => NullNode { nil: true, span }.into(),
                    _ => unreachable!("Atom: {}", text),
                }
            }
            AtomicContextAll::ALambdaContext(s) => {
                todo!()
            }
            AtomicContextAll::ANumberContext(s) => NumberLiteralNode::take(s.number_literal())?.into(),
            AtomicContextAll::AStringContext(s) => {
                todo!()
            }
            AtomicContextAll::ANamepathContext(s) => NamePathNode::take(s.namepath())?.into(),
            AtomicContextAll::Error(_) => {
                todo!()
            }
        };
        Some(body)
    }
}

impl<'i> Extractor<Number_literalContextAll<'i>> for NumberLiteralNode {
    fn take_one(node: &Number_literalContextAll<'i>) -> Option<Self> {
        let value = node.number()?.get_text();
        let suffix = IdentifierNode::take(node.identifier());
        let span = Range { start: node.start().start as u32, end: node.stop().stop as u32 };
        Some(Self { value, unit: suffix, span })
    }
}

impl<'i> Extractor<IdentifierContextAll<'i>> for IdentifierNode {
    fn take_one(node: &IdentifierContextAll<'i>) -> Option<Self> {
        if let Some(s) = node.UNICODE_ID() {
            return Some(IdentifierNode {
                name: s.get_text(),
                span: Range { start: s.symbol.start as u32, end: s.symbol.stop as u32 },
            });
        }
        if let Some(s) = node.RAW_ID() {
            return Some(IdentifierNode {
                name: s.symbol.text.trim_matches('`').to_string(),
                span: Range { start: s.symbol.start as u32, end: s.symbol.stop as u32 },
            });
        }
        None
    }
}