toktok_macros 0.2.1

toktok - WIP
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

#[derive(Debug)]
pub struct Ast<'a> {
    pub items: Vec<Item<'a>>,
}

#[derive(Debug)]
pub enum Item<'a> {
    UseStatement(UseStatement<'a>),
    Config(Config<'a>),
    Rule(Rule<'a>),
}

#[derive(Debug)]
pub struct UseStatement<'a>(pub &'a str);

#[derive(Debug)]
pub struct Config<'a> {
    pub name: Path<'a>,
    pub value: ConfigValue<'a>,
}

#[derive(Debug, PartialEq)]
pub enum ConfigValue<'a> {
    Array(Vec<ConfigValue<'a>>),
    Token(Token<'a>),
}

#[derive(Debug)]
pub struct Rule<'a> {
    pub is_public: bool,
    pub name: Ident<'a>,
    pub ret_type: RetType<'a>,
    pub productions: Vec<Production<'a>>,
}

#[derive(Debug)]
pub struct Production<'a> {
    pub combinator: CombinatorSeq<'a>,
    pub rust_expression: RustExpression<'a>,
    pub is_fallible: bool,
    #[expect(unused)]
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub enum Combinator<'a> {
    Seq(CombinatorSeq<'a>),
    Choice(CombinatorChoice<'a>),
    Opt(CombinatorOpt<'a>),
    Many0(CombinatorMany0<'a>),
    Many1(CombinatorMany1<'a>),
    Atom(CombinatorAtom<'a>),
}

impl<'a> Combinator<'a> {
    pub fn source(&self) -> &'a str {
        match self {
            Combinator::Seq(c) => c.source,
            Combinator::Choice(c) => c.source,
            Combinator::Opt(c) => c.source,
            Combinator::Many0(c) => c.source,
            Combinator::Many1(c) => c.source,
            Combinator::Atom(c) => c.source,
        }
    }
}

#[derive(Debug, PartialEq)]
pub struct CombinatorSeq<'a> {
    pub combinators: Vec<Combinator<'a>>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub struct CombinatorChoice<'a> {
    pub combinators: Vec<Combinator<'a>>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub struct CombinatorOpt<'a> {
    pub combinator: Box<Combinator<'a>>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub struct CombinatorMany0<'a> {
    pub combinator: Box<Combinator<'a>>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub struct CombinatorMany1<'a> {
    pub combinator: Box<Combinator<'a>>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub struct CombinatorAtom<'a> {
    pub kind: CombinatorAtomKind<'a>,
    pub source: &'a str,
}

#[derive(Debug, PartialEq)]
pub enum CombinatorAtomKind<'a> {
    Token(Token<'a>),
    Path(Path<'a>),
    FunctionCall(FunctionCall<'a>),
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum Token<'a> {
    TokenLit(TokenLit<'a>),
    TokenRegex(TokenRegex<'a>),
}

#[derive(Debug, PartialEq)]
pub struct FunctionCall<'a> {
    pub name: Path<'a>,
    pub args: Vec<Combinator<'a>>,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RetType<'a>(pub &'a str);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct RustExpression<'a>(pub &'a str);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TokenLit<'a>(pub &'a str);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct TokenRegex<'a>(pub &'a str);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Path<'a>(pub &'a str);

#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct Ident<'a>(pub &'a str);