vihaco-parser-core 0.1.1

Core chumsky-based parser primitives shared by the vihaco parser-derive crate.
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
78
79
80
81
82
83
84
85
86

// SPDX-FileCopyrightText: 2026 The vihaco Authors
// SPDX-License-Identifier: MIT

use crate::Parse;
use chumsky::error::Simple;
use chumsky::extra;
use chumsky::prelude::*;

type E<'src> = extra::Err<Simple<'src, char>>;

macro_rules! impl_uint {
    ($($t:ty),+) => {
        $(impl<'src> Parse<'src> for $t {
            fn parser() -> impl Parser<'src, &'src str, Self, E<'src>> {
                text::int(10).map(|s: &str| s.parse().unwrap())
            }
        })+
    };
}
impl_uint!(u64, u32, usize);

macro_rules! impl_sint {
    ($($t:ty),+) => {
        $(impl<'src> Parse<'src> for $t {
            fn parser() -> impl Parser<'src, &'src str, Self, E<'src>> {
                just('-')
                    .or_not()
                    .then(text::int(10))
                    .to_slice()
                    .map(|s: &str| s.parse().unwrap())
            }
        })+
    };
}
impl_sint!(i64, i32);

macro_rules! impl_float {
    ($($t:ty),+) => {
        $(impl<'src> Parse<'src> for $t {
            fn parser() -> impl Parser<'src, &'src str, Self, E<'src>> {
                // Accepts: optional unary `-`, integer, optional `.fraction`,
                // optional `e[+-]?digits`. Real .sst sources include both
                // scientific-notation literals like `1.9999999999998004e-6`
                // and negative basis components like `-0.5`; rejecting either
                // would force every consumer to roll its own float parser.
                let exp = one_of("eE")
                    .then(one_of("+-").or_not())
                    .then(text::digits(10));
                just('-')
                    .or_not()
                    .then(text::int(10))
                    .then(just('.').then(text::digits(10)).or_not())
                    .then(exp.or_not())
                    .to_slice()
                    .map(|s: &str| s.parse().unwrap())
            }
        })+
    };
}
impl_float!(f64, f32);

impl<'src> Parse<'src> for bool {
    fn parser() -> impl Parser<'src, &'src str, Self, E<'src>> {
        just("true").to(true).or(just("false").to(false))
    }
}

impl<'src> Parse<'src> for String {
    fn parser() -> impl Parser<'src, &'src str, Self, E<'src>> {
        any()
            .filter(|c: &char| !c.is_whitespace())
            .repeated()
            .at_least(1)
            .collect::<String>()
    }
}

pub fn ident<'src>() -> impl Parser<'src, &'src str, String, E<'src>> + Clone {
    any()
        .filter(|c: &char| {
            !c.is_whitespace() && !matches!(*c, ',' | ';' | '(' | ')' | '{' | '}' | '[' | ']')
        })
        .repeated()
        .at_least(1)
        .collect::<String>()
}