ebnf-parser 0.1.0

An LL(1) parser for the ISO 14977 EBNF notation
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

use std::fmt::{Debug, Display};

use crate::span::Span;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum TokenKind<'src> {
    Identifier(&'src str),
    Terminal(&'src str),
    Comment(&'src str),
    SpecialSeq(&'src str),
    Integer(usize),

    LBrace,
    RBrace,
    LBracket,
    RBracket,
    LParen,
    RParen,
    Pipe,
    Comma,
    Semicolon,
    Equal,
    Star,
    Dash,
}

impl Display for TokenKind<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TokenKind::Identifier(name) => write!(f, "{name}"),
            TokenKind::Terminal(text) => write!(f, "\"{text}\""),
            TokenKind::Comment(text) => write!(f, "(* {text} *)"),
            TokenKind::SpecialSeq(text) => write!(f, "? {text} ?"),
            TokenKind::Integer(num) => write!(f, "{num}"),
            TokenKind::LBrace => write!(f, "{{"),
            TokenKind::RBrace => write!(f, "}}"),
            TokenKind::LBracket => write!(f, "["),
            TokenKind::RBracket => write!(f, "]"),
            TokenKind::LParen => write!(f, "("),
            TokenKind::RParen => write!(f, ")"),
            TokenKind::Pipe => write!(f, "|"),
            TokenKind::Comma => write!(f, ","),
            TokenKind::Semicolon => write!(f, ";"),
            TokenKind::Equal => write!(f, "="),
            TokenKind::Star => write!(f, "*"),
            TokenKind::Dash => write!(f, "-"),
        }
    }
}

/// A token with positional information
#[derive(Clone)]
pub struct Token<'src> {
    pub kind: TokenKind<'src>,
    pub span: Span,
}

impl<'src> Token<'src> {
    pub(crate) fn new(kind: TokenKind<'src>, span: Span) -> Self {
        Self { kind, span }
    }
}

impl Debug for Token<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "({:?} @ {:?})", self.kind, self.span)
    }
}