#![allow(dead_code, unused_imports, non_camel_case_types)]
#![allow(missing_docs, rustdoc::missing_crate_level_docs)]
#![allow(clippy::unnecessary_cast)]
#![doc = include_str!("readme.md")]
mod parse_ast;
mod parse_cst;
use core::str::FromStr;
use std::{borrow::Cow, ops::Range, sync::OnceLock};
use yggdrasil_rt::*;
type Input<'i> = Box<State<'i, DejavuRule>>;
type Output<'i> = Result<Box<State<'i, DejavuRule>>, Box<State<'i, DejavuRule>>>;
#[doc = include_str!("railway.min.svg")]
#[repr(C)]
#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DejavuParser {}
impl YggdrasilParser for DejavuParser {
type Rule = DejavuRule;
fn parse_cst(input: &str, rule: Self::Rule) -> OutputResult<DejavuRule> {
self::parse_cst::parse_cst(input, rule)
}
}
#[repr(u32)]
#[derive(Copy, Clone, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum DejavuRule {
Root,
Element,
TextMany,
TextElement,
TEMPLATE_E,
TEXT_SPACE,
TEXT_WORD,
TEMPLATE_L,
TEMPLATE_R,
SpaceControl,
KW_END,
TemplateExport,
ExportItem,
KW_EXPORT,
KW_CLASS,
KW_TRAIT,
KW_TO,
KW_BY,
TemplateIf,
IfBegin,
IfElse,
IfElseIf,
IfEnd,
KW_IF,
KW_ELSE,
TemplateFor,
ForBegin,
ForElse,
ForEnd,
KW_FOR,
KW_IN,
Pattern,
BarePattern,
Expression,
ExpressionRest,
Infix,
Term,
Prefix,
Suffix,
Atomic,
String,
Number,
Digits,
Unit,
BIN,
OCT,
HEX,
NamepathFree,
Namepath,
Identifier,
Boolean,
WhiteSpace,
IgnoreText,
IgnoreRegex,
}
impl YggdrasilRule for DejavuRule {
fn is_ignore(&self) -> bool {
matches!(self, Self::IgnoreText | Self::IgnoreRegex | Self::WhiteSpace)
}
fn get_style(&self) -> &'static str {
match self {
Self::Root => "",
Self::Element => "",
Self::TextMany => "",
Self::TextElement => "",
Self::TEMPLATE_E => "",
Self::TEXT_SPACE => "",
Self::TEXT_WORD => "",
Self::TEMPLATE_L => "",
Self::TEMPLATE_R => "",
Self::SpaceControl => "",
Self::KW_END => "",
Self::TemplateExport => "",
Self::ExportItem => "",
Self::KW_EXPORT => "",
Self::KW_CLASS => "",
Self::KW_TRAIT => "",
Self::KW_TO => "",
Self::KW_BY => "",
Self::TemplateIf => "",
Self::IfBegin => "",
Self::IfElse => "",
Self::IfElseIf => "",
Self::IfEnd => "",
Self::KW_IF => "",
Self::KW_ELSE => "",
Self::TemplateFor => "",
Self::ForBegin => "",
Self::ForElse => "",
Self::ForEnd => "",
Self::KW_FOR => "",
Self::KW_IN => "",
Self::Pattern => "",
Self::BarePattern => "",
Self::Expression => "",
Self::ExpressionRest => "",
Self::Infix => "",
Self::Term => "",
Self::Prefix => "",
Self::Suffix => "",
Self::Atomic => "",
Self::String => "",
Self::Number => "",
Self::Digits => "",
Self::Unit => "",
Self::BIN => "",
Self::OCT => "",
Self::HEX => "",
Self::NamepathFree => "",
Self::Namepath => "",
Self::Identifier => "",
Self::Boolean => "",
Self::WhiteSpace => "",
_ => "",
}
}
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct RootNode {
pub element: Vec<ElementNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum ElementNode {
Export(TemplateExportNode),
For(TemplateForNode),
If(TemplateIfNode),
Text(TextManyNode),
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TextManyNode {
pub text_element: Vec<TextElementNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum TextElementNode {
Escape(TemplateENode),
TextSpace(TextSpaceNode),
TextWord(TextWordNode),
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateENode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TextSpaceNode {
pub text: String,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TextWordNode {
pub text: String,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateLNode {
pub space_control: Option<SpaceControlNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateRNode {
pub space_control: Option<SpaceControlNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SpaceControlNode {
Break0,
Break1,
Delete0,
Delete1,
Nothing,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwEndNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateExportNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ExportItemNode {
pub class: Option<NamepathFreeNode>,
pub language: Option<IdentifierNode>,
pub name: IdentifierNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwExportNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwClassNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwTraitNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwToNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwByNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateIfNode {
pub if_begin: IfBeginNode,
pub if_else: Option<IfElseNode>,
pub if_else_if: Vec<IfElseIfNode>,
pub if_end: IfEndNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IfBeginNode {
pub element: Vec<ElementNode>,
pub expression: ExpressionNode,
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IfElseNode {
pub element: Vec<ElementNode>,
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IfElseIfNode {
pub element: Vec<ElementNode>,
pub expression: ExpressionNode,
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IfEndNode {
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwIfNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwElseNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TemplateForNode {
pub for_begin: ForBeginNode,
pub for_else: Option<ForElseNode>,
pub for_end: ForEndNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ForBeginNode {
pub element: Vec<ElementNode>,
pub kw_in: Vec<KwInNode>,
pub pattern: PatternNode,
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub condition: Option<ExpressionNode>,
pub iterator: ExpressionNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ForElseNode {
pub element: Vec<ElementNode>,
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ForEndNode {
pub template_l: TemplateLNode,
pub template_r: TemplateRNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwForNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct KwInNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PatternNode {
BarePattern(BarePatternNode),
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BarePatternNode {
pub identifier: Vec<IdentifierNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ExpressionNode {
pub expression_rest: Vec<ExpressionRestNode>,
pub term: TermNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ExpressionRestNode {
pub infix: InfixNode,
pub term: TermNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum InfixNode {
Add,
Mul,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct TermNode {
pub atomic: AtomicNode,
pub prefix: Vec<PrefixNode>,
pub suffix: Vec<SuffixNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum PrefixNode {
Not,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum SuffixNode {
DotCall(IdentifierNode),
Null,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum AtomicNode {
Boolean(BooleanNode),
Identifier(IdentifierNode),
Number(NumberNode),
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum StringNode {
DoubleQuote,
SingleQuote,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum NumberNode {
Bin(BinNode),
Dec(DigitsNode),
Hex(HexNode),
Oct(OctNode),
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct DigitsNode {
pub text: String,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct UnitNode {
pub identifier: IdentifierNode,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct BinNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct OctNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct HexNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct NamepathFreeNode {
pub identifier: Vec<IdentifierNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct NamepathNode {
pub identifier: Vec<IdentifierNode>,
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct IdentifierNode {
pub span: Range<u32>,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BooleanNode {
False,
True,
}
#[derive(Clone, Debug, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub struct WhiteSpaceNode {
pub span: Range<u32>,
}