scarf_parser/parser/expressions/
operators.rs

1// =======================================================================
2// operators.rs
3// =======================================================================
4// Parsing for 1800-2023 A.8.6
5
6use crate::*;
7use chumsky::prelude::*;
8use scarf_syntax::*;
9
10pub fn unary_operator_parser<'a, I>() -> impl Parser<'a, I, UnaryOperator<'a>, ParserError<'a>>
11where
12    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
13{
14    choice((
15        token(Token::Plus).map(|a| UnaryOperator::Plus(a)),
16        token(Token::Minus).map(|a| UnaryOperator::Minus(a)),
17        token(Token::Exclamation).map(|a| UnaryOperator::Exclamation(a)),
18        token(Token::Tilde).map(|a| UnaryOperator::Tilde(a)),
19        token(Token::Amp).map(|a| UnaryOperator::Amp(a)),
20        token(Token::TildeAmp).map(|a| UnaryOperator::TildeAmp(a)),
21        token(Token::Pipe).map(|a| UnaryOperator::Pipe(a)),
22        token(Token::TildePipe).map(|a| UnaryOperator::TildePipe(a)),
23        token(Token::Caret).map(|a| UnaryOperator::Caret(a)),
24        token(Token::TildeCaret).map(|a| UnaryOperator::TildeCaret(a)),
25        token(Token::CaretTilde).map(|a| UnaryOperator::CaretTilde(a)),
26    ))
27}
28
29pub fn binary_operator_parser<'a, I>() -> impl Parser<'a, I, BinaryOperator<'a>, ParserError<'a>>
30where
31    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
32{
33    // Note: Got errors when combining these into one `choice`, seemingly because Rust used
34    // alphabetic identifiers for each parser type, and didn't like more than 26...
35    let temp1 = choice((
36        token(Token::Plus).map(|a| BinaryOperator::Plus(a)),
37        token(Token::Minus).map(|a| BinaryOperator::Minus(a)),
38        token(Token::Star).map(|a| BinaryOperator::Star(a)),
39        token(Token::Slash).map(|a| BinaryOperator::Slash(a)),
40        token(Token::Percent).map(|a| BinaryOperator::Percent(a)),
41        token(Token::EqEq).map(|a| BinaryOperator::EqEq(a)),
42        token(Token::ExclEq).map(|a| BinaryOperator::ExclEq(a)),
43        token(Token::EqEqEq).map(|a| BinaryOperator::EqEqEq(a)),
44        token(Token::ExclEqEq).map(|a| BinaryOperator::ExclEqEq(a)),
45        token(Token::EqEqQuest).map(|a| BinaryOperator::EqEqQuest(a)),
46        token(Token::ExclEqQuest).map(|a| BinaryOperator::ExclEqQuest(a)),
47        token(Token::AmpAmp).map(|a| BinaryOperator::AmpAmp(a)),
48        token(Token::PipePipe).map(|a| BinaryOperator::PipePipe(a)),
49        token(Token::StarStar).map(|a| BinaryOperator::StarStar(a)),
50    ));
51    let temp2 = choice((
52        token(Token::Lt).map(|a| BinaryOperator::Lt(a)),
53        token(Token::LtEq).map(|a| BinaryOperator::LtEq(a)),
54        token(Token::Gt).map(|a| BinaryOperator::Gt(a)),
55        token(Token::GtEq).map(|a| BinaryOperator::GtEq(a)),
56        token(Token::Amp).map(|a| BinaryOperator::Amp(a)),
57        token(Token::Pipe).map(|a| BinaryOperator::Pipe(a)),
58        token(Token::Caret).map(|a| BinaryOperator::Caret(a)),
59        token(Token::CaretTilde).map(|a| BinaryOperator::CaretTilde(a)),
60        token(Token::TildeCaret).map(|a| BinaryOperator::TildeCaret(a)),
61        token(Token::GtGt).map(|a| BinaryOperator::GtGt(a)),
62        token(Token::LtLt).map(|a| BinaryOperator::LtLt(a)),
63        token(Token::GtGtGt).map(|a| BinaryOperator::GtGtGt(a)),
64        token(Token::LtLtLt).map(|a| BinaryOperator::LtLtLt(a)),
65        token(Token::MinusGt).map(|a| BinaryOperator::MinusGt(a)),
66        token(Token::LtMinusGt).map(|a| BinaryOperator::LtMinusGt(a)),
67    ));
68    choice((temp1, temp2)).boxed()
69}
70
71pub fn inc_or_dec_operator_parser<'a, I>()
72-> impl Parser<'a, I, IncOrDecOperator<'a>, ParserError<'a>>
73where
74    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
75{
76    choice((
77        token(Token::PlusPlus).map(|a| IncOrDecOperator::PlusPlus(a)),
78        token(Token::MinusMinus).map(|a| IncOrDecOperator::MinusMinus(a)),
79    ))
80}
81
82pub fn unary_module_path_operator_parser<'a, I>()
83-> impl Parser<'a, I, UnaryModulePathOperator<'a>, ParserError<'a>>
84where
85    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
86{
87    choice((
88        token(Token::Exclamation).map(|a| UnaryModulePathOperator::Exclamation(a)),
89        token(Token::Tilde).map(|a| UnaryModulePathOperator::Tilde(a)),
90        token(Token::Amp).map(|a| UnaryModulePathOperator::Amp(a)),
91        token(Token::TildeAmp).map(|a| UnaryModulePathOperator::TildeAmp(a)),
92        token(Token::Pipe).map(|a| UnaryModulePathOperator::Pipe(a)),
93        token(Token::TildePipe).map(|a| UnaryModulePathOperator::TildePipe(a)),
94        token(Token::Caret).map(|a| UnaryModulePathOperator::Caret(a)),
95        token(Token::TildeCaret).map(|a| UnaryModulePathOperator::TildeCaret(a)),
96        token(Token::CaretTilde).map(|a| UnaryModulePathOperator::CaretTilde(a)),
97    ))
98}
99
100pub fn binary_module_path_operator_parser<'a, I>()
101-> impl Parser<'a, I, BinaryModulePathOperator<'a>, ParserError<'a>>
102where
103    I: ValueInput<'a, Token = Token<'a>, Span = ParserSpan>,
104{
105    choice((
106        token(Token::EqEq).map(|a| BinaryModulePathOperator::EqEq(a)),
107        token(Token::ExclEq).map(|a| BinaryModulePathOperator::ExclEq(a)),
108        token(Token::AmpAmp).map(|a| BinaryModulePathOperator::AmpAmp(a)),
109        token(Token::PipePipe).map(|a| BinaryModulePathOperator::PipePipe(a)),
110        token(Token::Amp).map(|a| BinaryModulePathOperator::Amp(a)),
111        token(Token::Pipe).map(|a| BinaryModulePathOperator::Pipe(a)),
112        token(Token::Caret).map(|a| BinaryModulePathOperator::Caret(a)),
113        token(Token::CaretTilde).map(|a| BinaryModulePathOperator::CaretTilde(a)),
114        token(Token::TildeCaret).map(|a| BinaryModulePathOperator::TildeCaret(a)),
115    ))
116}
scarf_parser/parser/expressions/operators.rs

scarf_parser/parser/expressions/
operators.rs
