mf_expression/parser/
standard.rs

1use crate::lexer::{Bracket, Identifier, TokenKind};
2use crate::parser::ast::{AstNodeError, Node};
3use crate::parser::constants::{Associativity, BINARY_OPERATORS, UNARY_OPERATORS};
4use crate::parser::parser::Parser;
5use crate::parser::result::ParserResult;
6use crate::parser::NodeMetadata;
7
8#[derive(Debug)]
9pub struct Standard;
10
11impl<'arena, 'token_ref> Parser<'arena, 'token_ref, Standard> {
12    pub fn parse(&self) -> ParserResult<'arena> {
13        let root = self.binary_expression(0);
14
15        ParserResult {
16            root,
17            is_complete: self.is_done(),
18            metadata: self.node_metadata.clone().map(|t| t.into_inner()),
19        }
20    }
21
22    #[cfg_attr(feature = "stack-protection", recursive::recursive)]
23    fn binary_expression(
24        &self,
25        precedence: u8,
26    ) -> &'arena Node<'arena> {
27        let mut node_left = self.unary_expression();
28        let Some(mut token) = self.current() else {
29            return node_left;
30        };
31
32        while let TokenKind::Operator(operator) = &token.kind {
33            if self.is_done() {
34                break;
35            }
36
37            let Some(op) = BINARY_OPERATORS.get(operator) else {
38                break;
39            };
40
41            if op.precedence < precedence {
42                break;
43            }
44
45            self.next();
46            let node_right = match op.associativity {
47                Associativity::Left => {
48                    self.binary_expression(op.precedence + 1)
49                },
50                _ => self.binary_expression(op.precedence),
51            };
52
53            node_left = self.node(
54                Node::Binary {
55                    operator: *operator,
56                    left: node_left,
57                    right: node_right,
58                },
59                |h| NodeMetadata {
60                    span: h.span(node_left, node_right).unwrap_or_default(),
61                },
62            );
63
64            let Some(t) = self.current() else {
65                break;
66            };
67            token = t;
68        }
69
70        if precedence == 0 {
71            if let Some(conditional_node) =
72                self.conditional(node_left, &|_| self.binary_expression(0))
73            {
74                node_left = conditional_node;
75            }
76        }
77
78        node_left
79    }
80
81    fn unary_expression(&self) -> &'arena Node<'arena> {
82        let Some(token) = self.current() else {
83            return self.error(AstNodeError::Custom {
84                message: self
85                    .bump
86                    .alloc_str("Unexpected end of unary expression"),
87                span: (self.prev_token_end(), self.prev_token_end()),
88            });
89        };
90
91        if self.depth() > 0
92            && token.kind
93                == TokenKind::Identifier(Identifier::CallbackReference)
94        {
95            self.next();
96
97            let node =
98                self.node(Node::Pointer, |_| NodeMetadata { span: token.span });
99            let (n, _) =
100                self.with_postfix(node, &|_| self.binary_expression(0));
101            return n;
102        }
103
104        if let TokenKind::Operator(operator) = &token.kind {
105            let Some(unary_operator) = UNARY_OPERATORS.get(operator) else {
106                return self.error(AstNodeError::UnexpectedToken {
107                    expected: "UnaryOperator",
108                    received: self
109                        .bump
110                        .alloc_str(token.kind.to_string().as_str()),
111                    span: token.span,
112                });
113            };
114
115            self.next();
116            let expr = self.binary_expression(unary_operator.precedence);
117            let node = self.node(
118                Node::Unary { operator: *operator, node: expr },
119                |h| NodeMetadata {
120                    span: (
121                        token.span.0,
122                        h.metadata(expr).map(|n| n.span.1).unwrap_or_default(),
123                    ),
124                },
125            );
126
127            return node;
128        }
129
130        if let Some(interval_node) =
131            self.interval(&|_| self.binary_expression(0))
132        {
133            return interval_node;
134        }
135
136        if token.kind == TokenKind::Bracket(Bracket::LeftParenthesis) {
137            let p_start = self.current().map(|s| s.span.0);
138
139            self.next();
140            let binary_node = self.binary_expression(0);
141            if let Some(error_node) =
142                self.expect(TokenKind::Bracket(Bracket::RightParenthesis))
143            {
144                return error_node;
145            };
146
147            let expr =
148                self.node(Node::Parenthesized(binary_node), |_| NodeMetadata {
149                    span: (p_start.unwrap_or_default(), self.prev_token_end()),
150                });
151
152            let (n, _) =
153                self.with_postfix(expr, &|_| self.binary_expression(0));
154            return n;
155        }
156
157        self.literal(&|_| self.binary_expression(0))
158    }
159}
mf_expression/parser/standard.rs

mf_expression/parser/
standard.rs
