cas-parser 0.2.0

Parser for the CalcScript 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
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

pub mod op;
pub mod pair;

use cas_error::Error;
use crate::{
    parser::{error::UnexpectedToken, garbage::Garbage, Parser, Parse},
    tokenizer::TokenKind,
};
use std::ops::Range;

/// Generates a unit struct for each token kind, as well as a simple [`Parse`] implementation for
/// each token kind. This enables the parser to use and request token kinds as a type, which is
/// much more ergonomic than using a string.
macro_rules! token_kinds {
    ($($name:ident)*) => {
        $(
            #[derive(Clone, Debug, PartialEq)]
            pub struct $name<'source> {
                pub lexeme: &'source str,
                pub span: Range<usize>,
            }

            impl<'source> Parse<'source> for $name<'source> {
                fn std_parse(
                    input: &mut Parser<'source>,
                    _: &mut Vec<Error>
                ) -> Result<Self, Vec<Error>> {
                    let token = input.next_token().map_err(|e| vec![e])?;

                    if token.kind == TokenKind::$name {
                        Ok(Self {
                            lexeme: token.lexeme,
                            span: token.span,
                        })
                    } else {
                        Err(vec![Error::new(vec![token.span], UnexpectedToken {
                            expected: &[TokenKind::$name],
                            found: token.kind,
                        })])
                    }
                }
            }

            impl<'source> Garbage for $name<'source> {
                fn garbage() -> Self {
                    Self { lexeme: "", span: 0..0 }
                }
            }
        )*
    };
}

token_kinds!(
    NewLine
    Whitespace
    Eq
    NotEq
    ApproxEq
    ApproxNotEq
    Add
    Sub
    Mul
    Div
    Mod
    Exp
    Greater
    GreaterEq
    Less
    LessEq
    Not
    Factorial
    And
    Or
    BitAnd
    BitOr
    BitNot
    BitRight
    BitLeft
    Assign
    AddAssign
    SubAssign
    MulAssign
    DivAssign
    ModAssign
    ExpAssign
    AndAssign
    OrAssign
    BitAndAssign
    BitOrAssign
    BitRightAssign
    BitLeftAssign
    Bin
    Oct
    Hex
    Name
    Keyword
    Comma
    OpenParen
    CloseParen
    OpenCurly
    CloseCurly
    OpenSquare
    CloseSquare
    Quote
    Semicolon
    Int
    Boolean
    Dot
    RangeHalfOpen
    RangeClosed
    Symbol
);