dejavu_parser/dejavu/
mod.rs

1#![allow(dead_code, unused_imports, non_camel_case_types)]
2#![allow(missing_docs, rustdoc::missing_crate_level_docs)]
3#![allow(clippy::unnecessary_cast)]
4#![doc = include_str!("readme.md")]
5
6mod parse_ast;
7mod parse_cst;
8
9use core::str::FromStr;
10use std::{borrow::Cow, ops::Range, sync::OnceLock};
11use yggdrasil_rt::*;
12
13type Input<'i> = Box<State<'i, DejavuRule>>;
14type Output<'i> = Result<Box<State<'i, DejavuRule>>, Box<State<'i, DejavuRule>>>;
15
16#[doc = include_str!("railway.min.svg")]
17#[repr(C)]
18#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Ord, PartialOrd, Hash)]
19#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
20pub struct DejavuParser {}
21
22impl YggdrasilParser for DejavuParser {
23    type Rule = DejavuRule;
24    fn parse_cst(input: &str, rule: Self::Rule) -> OutputResult<DejavuRule> {
25        self::parse_cst::parse_cst(input, rule)
26    }
27}
28
29#[repr(u32)]
30#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
31#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
32pub enum DejavuRule {
33    Root,
34    Element,
35    TextMany,
36    TextElement,
37    TEMPLATE_E,
38    TEXT_SPACE,
39    TEXT_WORD,
40    TEMPLATE_L,
41    TEMPLATE_R,
42    SpaceControl,
43    KW_END,
44    TemplateExport,
45    ExportItem,
46    KW_EXPORT,
47    KW_CLASS,
48    KW_TRAIT,
49    KW_TO,
50    KW_BY,
51    TemplateIf,
52    IfBegin,
53    IfElse,
54    IfElseIf,
55    IfEnd,
56    KW_IF,
57    KW_ELSE,
58    TemplateFor,
59    ForBegin,
60    ForElse,
61    ForEnd,
62    KW_FOR,
63    KW_IN,
64    Pattern,
65    BarePattern,
66    Expression,
67    ExpressionRest,
68    Infix,
69    Term,
70    Prefix,
71    Suffix,
72    Atomic,
73    String,
74    Number,
75    Digits,
76    Unit,
77    BIN,
78    OCT,
79    HEX,
80    NamepathFree,
81    Namepath,
82    Identifier,
83    Boolean,
84    WhiteSpace,
85    /// Label for text literal
86    IgnoreText,
87    /// Label for regex literal
88    IgnoreRegex,
89}
90
91impl YggdrasilRule for DejavuRule {
92    fn is_ignore(&self) -> bool {
93        matches!(self, Self::IgnoreText | Self::IgnoreRegex | Self::WhiteSpace)
94    }
95
96    fn get_style(&self) -> &'static str {
97        match self {
98            Self::Root => "",
99            Self::Element => "",
100            Self::TextMany => "",
101            Self::TextElement => "",
102            Self::TEMPLATE_E => "",
103            Self::TEXT_SPACE => "",
104            Self::TEXT_WORD => "",
105            Self::TEMPLATE_L => "",
106            Self::TEMPLATE_R => "",
107            Self::SpaceControl => "",
108            Self::KW_END => "",
109            Self::TemplateExport => "",
110            Self::ExportItem => "",
111            Self::KW_EXPORT => "",
112            Self::KW_CLASS => "",
113            Self::KW_TRAIT => "",
114            Self::KW_TO => "",
115            Self::KW_BY => "",
116            Self::TemplateIf => "",
117            Self::IfBegin => "",
118            Self::IfElse => "",
119            Self::IfElseIf => "",
120            Self::IfEnd => "",
121            Self::KW_IF => "",
122            Self::KW_ELSE => "",
123            Self::TemplateFor => "",
124            Self::ForBegin => "",
125            Self::ForElse => "",
126            Self::ForEnd => "",
127            Self::KW_FOR => "",
128            Self::KW_IN => "",
129            Self::Pattern => "",
130            Self::BarePattern => "",
131            Self::Expression => "",
132            Self::ExpressionRest => "",
133            Self::Infix => "",
134            Self::Term => "",
135            Self::Prefix => "",
136            Self::Suffix => "",
137            Self::Atomic => "",
138            Self::String => "",
139            Self::Number => "",
140            Self::Digits => "",
141            Self::Unit => "",
142            Self::BIN => "",
143            Self::OCT => "",
144            Self::HEX => "",
145            Self::NamepathFree => "",
146            Self::Namepath => "",
147            Self::Identifier => "",
148            Self::Boolean => "",
149            Self::WhiteSpace => "",
150            _ => "",
151        }
152    }
153}
154#[derive(Clone, Debug, Hash)]
155#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
156pub struct RootNode {
157    pub element: Vec<ElementNode>,
158    pub span: Range<u32>,
159}
160#[derive(Clone, Debug, Hash)]
161#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
162pub enum ElementNode {
163    Export(TemplateExportNode),
164    For(TemplateForNode),
165    If(TemplateIfNode),
166    Text(TextManyNode),
167}
168#[derive(Clone, Debug, Hash)]
169#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
170pub struct TextManyNode {
171    pub text_element: Vec<TextElementNode>,
172    pub span: Range<u32>,
173}
174#[derive(Clone, Debug, Hash)]
175#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
176pub enum TextElementNode {
177    Escape(TemplateENode),
178    TextSpace(TextSpaceNode),
179    TextWord(TextWordNode),
180}
181#[derive(Clone, Debug, Hash)]
182#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
183pub struct TemplateENode {
184    pub span: Range<u32>,
185}
186#[derive(Clone, Debug, Hash)]
187#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
188pub struct TextSpaceNode {
189    pub text: String,
190    pub span: Range<u32>,
191}
192#[derive(Clone, Debug, Hash)]
193#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
194pub struct TextWordNode {
195    pub text: String,
196    pub span: Range<u32>,
197}
198#[derive(Clone, Debug, Hash)]
199#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
200pub struct TemplateLNode {
201    pub space_control: Option<SpaceControlNode>,
202    pub span: Range<u32>,
203}
204#[derive(Clone, Debug, Hash)]
205#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
206pub struct TemplateRNode {
207    pub space_control: Option<SpaceControlNode>,
208    pub span: Range<u32>,
209}
210#[derive(Clone, Debug, Hash)]
211#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
212pub enum SpaceControlNode {
213    Break0,
214    Break1,
215    Delete0,
216    Delete1,
217    Nothing,
218}
219#[derive(Clone, Debug, Hash)]
220#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
221pub struct KwEndNode {
222    pub span: Range<u32>,
223}
224#[derive(Clone, Debug, Hash)]
225#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
226pub struct TemplateExportNode {
227    pub span: Range<u32>,
228}
229#[derive(Clone, Debug, Hash)]
230#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
231pub struct ExportItemNode {
232    pub class: Option<NamepathFreeNode>,
233    pub language: Option<IdentifierNode>,
234    pub name: IdentifierNode,
235    pub span: Range<u32>,
236}
237#[derive(Clone, Debug, Hash)]
238#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
239pub struct KwExportNode {
240    pub span: Range<u32>,
241}
242#[derive(Clone, Debug, Hash)]
243#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
244pub struct KwClassNode {
245    pub span: Range<u32>,
246}
247#[derive(Clone, Debug, Hash)]
248#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
249pub struct KwTraitNode {
250    pub span: Range<u32>,
251}
252#[derive(Clone, Debug, Hash)]
253#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
254pub struct KwToNode {
255    pub span: Range<u32>,
256}
257#[derive(Clone, Debug, Hash)]
258#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
259pub struct KwByNode {
260    pub span: Range<u32>,
261}
262#[derive(Clone, Debug, Hash)]
263#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
264pub struct TemplateIfNode {
265    pub if_begin: IfBeginNode,
266    pub if_else: Option<IfElseNode>,
267    pub if_else_if: Vec<IfElseIfNode>,
268    pub if_end: IfEndNode,
269    pub span: Range<u32>,
270}
271#[derive(Clone, Debug, Hash)]
272#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
273pub struct IfBeginNode {
274    pub element: Vec<ElementNode>,
275    pub expression: ExpressionNode,
276    pub template_l: TemplateLNode,
277    pub template_r: TemplateRNode,
278    pub span: Range<u32>,
279}
280#[derive(Clone, Debug, Hash)]
281#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
282pub struct IfElseNode {
283    pub element: Vec<ElementNode>,
284    pub template_l: TemplateLNode,
285    pub template_r: TemplateRNode,
286    pub span: Range<u32>,
287}
288#[derive(Clone, Debug, Hash)]
289#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
290pub struct IfElseIfNode {
291    pub element: Vec<ElementNode>,
292    pub expression: ExpressionNode,
293    pub template_l: TemplateLNode,
294    pub template_r: TemplateRNode,
295    pub span: Range<u32>,
296}
297#[derive(Clone, Debug, Hash)]
298#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
299pub struct IfEndNode {
300    pub template_l: TemplateLNode,
301    pub template_r: TemplateRNode,
302    pub span: Range<u32>,
303}
304#[derive(Clone, Debug, Hash)]
305#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
306pub struct KwIfNode {
307    pub span: Range<u32>,
308}
309#[derive(Clone, Debug, Hash)]
310#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
311pub struct KwElseNode {
312    pub span: Range<u32>,
313}
314#[derive(Clone, Debug, Hash)]
315#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
316pub struct TemplateForNode {
317    pub for_begin: ForBeginNode,
318    pub for_else: Option<ForElseNode>,
319    pub for_end: ForEndNode,
320    pub span: Range<u32>,
321}
322#[derive(Clone, Debug, Hash)]
323#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
324pub struct ForBeginNode {
325    pub element: Vec<ElementNode>,
326    pub kw_in: Vec<KwInNode>,
327    pub pattern: PatternNode,
328    pub template_l: TemplateLNode,
329    pub template_r: TemplateRNode,
330    pub condition: Option<ExpressionNode>,
331    pub iterator: ExpressionNode,
332    pub span: Range<u32>,
333}
334#[derive(Clone, Debug, Hash)]
335#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
336pub struct ForElseNode {
337    pub element: Vec<ElementNode>,
338    pub template_l: TemplateLNode,
339    pub template_r: TemplateRNode,
340    pub span: Range<u32>,
341}
342#[derive(Clone, Debug, Hash)]
343#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
344pub struct ForEndNode {
345    pub template_l: TemplateLNode,
346    pub template_r: TemplateRNode,
347    pub span: Range<u32>,
348}
349#[derive(Clone, Debug, Hash)]
350#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
351pub struct KwForNode {
352    pub span: Range<u32>,
353}
354#[derive(Clone, Debug, Hash)]
355#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
356pub struct KwInNode {
357    pub span: Range<u32>,
358}
359#[derive(Clone, Debug, Hash)]
360#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
361pub enum PatternNode {
362    BarePattern(BarePatternNode),
363}
364#[derive(Clone, Debug, Hash)]
365#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
366pub struct BarePatternNode {
367    pub identifier: Vec<IdentifierNode>,
368    pub span: Range<u32>,
369}
370#[derive(Clone, Debug, Hash)]
371#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
372pub struct ExpressionNode {
373    pub expression_rest: Vec<ExpressionRestNode>,
374    pub term: TermNode,
375    pub span: Range<u32>,
376}
377#[derive(Clone, Debug, Hash)]
378#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
379pub struct ExpressionRestNode {
380    pub infix: InfixNode,
381    pub term: TermNode,
382    pub span: Range<u32>,
383}
384#[derive(Clone, Debug, Hash)]
385#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
386pub enum InfixNode {
387    Add,
388    Mul,
389}
390#[derive(Clone, Debug, Hash)]
391#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
392pub struct TermNode {
393    pub atomic: AtomicNode,
394    pub prefix: Vec<PrefixNode>,
395    pub suffix: Vec<SuffixNode>,
396    pub span: Range<u32>,
397}
398#[derive(Clone, Debug, Hash)]
399#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
400pub enum PrefixNode {
401    Not,
402}
403#[derive(Clone, Debug, Hash)]
404#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
405pub enum SuffixNode {
406    DotCall(IdentifierNode),
407    Null,
408}
409#[derive(Clone, Debug, Hash)]
410#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
411pub enum AtomicNode {
412    Boolean(BooleanNode),
413    Identifier(IdentifierNode),
414    Number(NumberNode),
415}
416#[derive(Clone, Debug, Hash)]
417#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
418pub enum StringNode {
419    DoubleQuote,
420    SingleQuote,
421}
422#[derive(Clone, Debug, Hash)]
423#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
424pub enum NumberNode {
425    Bin(BinNode),
426    Dec(DigitsNode),
427    Hex(HexNode),
428    Oct(OctNode),
429}
430#[derive(Clone, Debug, Hash)]
431#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
432pub struct DigitsNode {
433    pub text: String,
434    pub span: Range<u32>,
435}
436#[derive(Clone, Debug, Hash)]
437#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
438pub struct UnitNode {
439    pub identifier: IdentifierNode,
440    pub span: Range<u32>,
441}
442#[derive(Clone, Debug, Hash)]
443#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
444pub struct BinNode {
445    pub span: Range<u32>,
446}
447#[derive(Clone, Debug, Hash)]
448#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
449pub struct OctNode {
450    pub span: Range<u32>,
451}
452#[derive(Clone, Debug, Hash)]
453#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
454pub struct HexNode {
455    pub span: Range<u32>,
456}
457#[derive(Clone, Debug, Hash)]
458#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
459pub struct NamepathFreeNode {
460    pub identifier: Vec<IdentifierNode>,
461    pub span: Range<u32>,
462}
463#[derive(Clone, Debug, Hash)]
464#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
465pub struct NamepathNode {
466    pub identifier: Vec<IdentifierNode>,
467    pub span: Range<u32>,
468}
469#[derive(Clone, Debug, Hash)]
470#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
471pub struct IdentifierNode {
472    pub span: Range<u32>,
473}
474#[derive(Clone, Debug, Hash)]
475#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
476pub enum BooleanNode {
477    False,
478    True,
479}
480#[derive(Clone, Debug, Hash)]
481#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
482pub struct WhiteSpaceNode {
483    pub span: Range<u32>,
484}
dejavu_parser/dejavu/mod.rs

dejavu_parser/dejavu/
mod.rs
