scarf-parser 0.1.0

A helper crate of scarf for parsing a SystemVerilog source file
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

// =======================================================================
// operators.rs
// =======================================================================
// Parsing for 1800-2023 A.8.6

use crate::*;
use chumsky::prelude::*;
use scarf_syntax::*;

pub fn unary_operator_parser<'a, I>() -> impl Parser<'a, I, UnaryOperator<'a>, ParserError<'a>>
where
    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
{
    choice((
        token(Token::Plus).map(|a| UnaryOperator::Plus(a)),
        token(Token::Minus).map(|a| UnaryOperator::Minus(a)),
        token(Token::Exclamation).map(|a| UnaryOperator::Exclamation(a)),
        token(Token::Tilde).map(|a| UnaryOperator::Tilde(a)),
        token(Token::Amp).map(|a| UnaryOperator::Amp(a)),
        token(Token::TildeAmp).map(|a| UnaryOperator::TildeAmp(a)),
        token(Token::Pipe).map(|a| UnaryOperator::Pipe(a)),
        token(Token::TildePipe).map(|a| UnaryOperator::TildePipe(a)),
        token(Token::Caret).map(|a| UnaryOperator::Caret(a)),
        token(Token::TildeCaret).map(|a| UnaryOperator::TildeCaret(a)),
        token(Token::CaretTilde).map(|a| UnaryOperator::CaretTilde(a)),
    ))
}

pub fn binary_operator_parser<'a, I>() -> impl Parser<'a, I, BinaryOperator<'a>, ParserError<'a>>
where
    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
{
    // Note: Got errors when combining these into one `choice`, seemingly because Rust used
    // alphabetic identifiers for each parser type, and didn't like more than 26...
    let temp1 = choice((
        token(Token::Plus).map(|a| BinaryOperator::Plus(a)),
        token(Token::Minus).map(|a| BinaryOperator::Minus(a)),
        token(Token::Star).map(|a| BinaryOperator::Star(a)),
        token(Token::Slash).map(|a| BinaryOperator::Slash(a)),
        token(Token::Percent).map(|a| BinaryOperator::Percent(a)),
        token(Token::EqEq).map(|a| BinaryOperator::EqEq(a)),
        token(Token::ExclEq).map(|a| BinaryOperator::ExclEq(a)),
        token(Token::EqEqEq).map(|a| BinaryOperator::EqEqEq(a)),
        token(Token::ExclEqEq).map(|a| BinaryOperator::ExclEqEq(a)),
        token(Token::EqEqQuest).map(|a| BinaryOperator::EqEqQuest(a)),
        token(Token::ExclEqQuest).map(|a| BinaryOperator::ExclEqQuest(a)),
        token(Token::AmpAmp).map(|a| BinaryOperator::AmpAmp(a)),
        token(Token::PipePipe).map(|a| BinaryOperator::PipePipe(a)),
        token(Token::StarStar).map(|a| BinaryOperator::StarStar(a)),
    ));
    let temp2 = choice((
        token(Token::Lt).map(|a| BinaryOperator::Lt(a)),
        token(Token::LtEq).map(|a| BinaryOperator::LtEq(a)),
        token(Token::Gt).map(|a| BinaryOperator::Gt(a)),
        token(Token::GtEq).map(|a| BinaryOperator::GtEq(a)),
        token(Token::Amp).map(|a| BinaryOperator::Amp(a)),
        token(Token::Pipe).map(|a| BinaryOperator::Pipe(a)),
        token(Token::Caret).map(|a| BinaryOperator::Caret(a)),
        token(Token::CaretTilde).map(|a| BinaryOperator::CaretTilde(a)),
        token(Token::TildeCaret).map(|a| BinaryOperator::TildeCaret(a)),
        token(Token::GtGt).map(|a| BinaryOperator::GtGt(a)),
        token(Token::LtLt).map(|a| BinaryOperator::LtLt(a)),
        token(Token::GtGtGt).map(|a| BinaryOperator::GtGtGt(a)),
        token(Token::LtLtLt).map(|a| BinaryOperator::LtLtLt(a)),
        token(Token::MinusGt).map(|a| BinaryOperator::MinusGt(a)),
        token(Token::LtMinusGt).map(|a| BinaryOperator::LtMinusGt(a)),
    ));
    choice((temp1, temp2)).boxed()
}

pub fn inc_or_dec_operator_parser<'a, I>()
-> impl Parser<'a, I, IncOrDecOperator<'a>, ParserError<'a>>
where
    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
{
    choice((
        token(Token::PlusPlus).map(|a| IncOrDecOperator::PlusPlus(a)),
        token(Token::MinusMinus).map(|a| IncOrDecOperator::MinusMinus(a)),
    ))
}

pub fn unary_module_path_operator_parser<'a, I>()
-> impl Parser<'a, I, UnaryModulePathOperator<'a>, ParserError<'a>>
where
    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
{
    choice((
        token(Token::Exclamation).map(|a| UnaryModulePathOperator::Exclamation(a)),
        token(Token::Tilde).map(|a| UnaryModulePathOperator::Tilde(a)),
        token(Token::Amp).map(|a| UnaryModulePathOperator::Amp(a)),
        token(Token::TildeAmp).map(|a| UnaryModulePathOperator::TildeAmp(a)),
        token(Token::Pipe).map(|a| UnaryModulePathOperator::Pipe(a)),
        token(Token::TildePipe).map(|a| UnaryModulePathOperator::TildePipe(a)),
        token(Token::Caret).map(|a| UnaryModulePathOperator::Caret(a)),
        token(Token::TildeCaret).map(|a| UnaryModulePathOperator::TildeCaret(a)),
        token(Token::CaretTilde).map(|a| UnaryModulePathOperator::CaretTilde(a)),
    ))
}

pub fn binary_module_path_operator_parser<'a, I>()
-> impl Parser<'a, I, BinaryModulePathOperator<'a>, ParserError<'a>>
where
    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
{
    choice((
        token(Token::EqEq).map(|a| BinaryModulePathOperator::EqEq(a)),
        token(Token::ExclEq).map(|a| BinaryModulePathOperator::ExclEq(a)),
        token(Token::AmpAmp).map(|a| BinaryModulePathOperator::AmpAmp(a)),
        token(Token::PipePipe).map(|a| BinaryModulePathOperator::PipePipe(a)),
        token(Token::Amp).map(|a| BinaryModulePathOperator::Amp(a)),
        token(Token::Pipe).map(|a| BinaryModulePathOperator::Pipe(a)),
        token(Token::Caret).map(|a| BinaryModulePathOperator::Caret(a)),
        token(Token::CaretTilde).map(|a| BinaryModulePathOperator::CaretTilde(a)),
        token(Token::TildeCaret).map(|a| BinaryModulePathOperator::TildeCaret(a)),
    ))
}