kamo-macros 0.1.2

A macro for parsing s-expressions into kamo Values.
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

use pest::iterators::Pair;

use crate::sexpr::{error::Error, parser::Rule};

pub fn get_escape(pair: Pair<'_, Rule>) -> Result<Option<char>, Error<'_>> {
    if matches!(pair.as_rule(), Rule::symbol_escape | Rule::string_escape) {
        let mut pairs = pair.into_inner();
        let pair = pairs.next().expect("inner pair missing");

        let c = match pair.as_rule() {
            Rule::character_code => {
                let code = pair.as_str();
                let code = u32::from_str_radix(code, 16).expect("invalid character code");

                char::from_u32(code).ok_or_else(|| Error::InvalidCodePoint(pair.as_span(), code))?
            }
            Rule::symbol_mnemonic => match pair.as_str() {
                "|" => '|',
                "\"" => '"',
                "\\" => '\\',
                "a" => '\x07',
                "b" => '\x08',
                "t" => '\t',
                "n" => '\n',
                "r" => '\r',
                _ => return Err(Error::ExpectedEscape(pair.as_span())),
            },
            Rule::string_mnemonic => match pair.as_str() {
                "\"" => '"',
                "\\" => '\\',
                "a" => '\x07',
                "b" => '\x08',
                "t" => '\t',
                "n" => '\n',
                "r" => '\r',
                _ => return Err(Error::ExpectedEscape(pair.as_span())),
            },
            Rule::string_ilws => return Ok(None),
            _ => unreachable!(),
        };
        assert!(pairs.next().is_none(), "too many inner pairs");
        Ok(Some(c))
    } else {
        Err(Error::ExpectedEscape(pair.as_span()))
    }
}