xidl_parser/typed_ast/
expr.rs

1use serde::{Deserialize, Serialize};
2use xidl_parser_derive::Parser;
3
4use crate::typed_ast::Identifier;
5
6#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
7pub struct ConstExpr(pub OrExpr);
8
9#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
10pub enum OrExpr {
11    XorExpr(XorExpr),
12    OrExpr(Box<OrExpr>, XorExpr),
13}
14
15#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
16pub enum XorExpr {
17    AndExpr(AndExpr),
18    XorExpr(Box<XorExpr>, AndExpr),
19}
20
21#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
22pub enum AndExpr {
23    ShiftExpr(ShiftExpr),
24    AndExpr(Box<AndExpr>, ShiftExpr),
25}
26
27#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
28pub enum ShiftExpr {
29    AddExpr(AddExpr),
30    LeftShiftExpr(Box<ShiftExpr>, AddExpr),
31    RightShiftExpr(Box<ShiftExpr>, AddExpr),
32}
33
34#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
35pub enum AddExpr {
36    MultExpr(MultExpr),
37    AddExpr(Box<AddExpr>, MultExpr),
38    SubExpr(Box<AddExpr>, MultExpr),
39}
40
41#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
42pub enum MultExpr {
43    UnaryExpr(UnaryExpr),
44    MultExpr(Box<MultExpr>, UnaryExpr),
45    DivExpr(Box<MultExpr>, UnaryExpr),
46    ModExpr(Box<MultExpr>, UnaryExpr),
47}
48
49#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
50pub enum UnaryExpr {
51    UnaryExpr(UnaryOperator, PrimaryExpr),
52    PrimaryExpr(PrimaryExpr),
53}
54
55#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
56pub enum PrimaryExpr {
57    ScopedName(ScopedName),
58    Literal(Literal),
59    ConstExpr(Box<ConstExpr>),
60}
61
62#[derive(Debug, Clone, Serialize, Deserialize)]
63pub enum UnaryOperator {
64    Add,
65    Sub,
66    Not,
67}
68
69impl<'a> crate::parser::FromTreeSitter<'a> for UnaryOperator {
70    fn from_node(
71        node: tree_sitter::Node<'a>,
72        ctx: &mut crate::parser::ParseContext<'a>,
73    ) -> crate::error::ParserResult<Self> {
74        #[allow(clippy::never_loop)]
75        for ch in node.children(&mut node.walk()) {
76            return match ctx.node_text(&ch)? {
77                "+" => Ok(Self::Add),
78                "-" => Ok(Self::Sub),
79                "~" => Ok(Self::Not),
80                _ => Err(crate::error::ParseError::UnexpectedNode(format!(
81                    "parent: {}, got: {}",
82                    node.kind(),
83                    ch.kind()
84                ))),
85            };
86        }
87        unreachable!()
88    }
89}
90
91#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
92pub struct ScopedName {
93    #[ts(id = "scoped_name")]
94    pub scoped_name: Option<Box<ScopedName>>,
95    pub identifier: Identifier,
96    #[ts(id = "-", text)]
97    pub node_text: String,
98}
99
100#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
101pub enum Literal {
102    IntegerLiteral(IntegerLiteral),
103    FloatingPtLiteral(FloatingPtLiteral),
104    // FixedPtLiteral,
105    CharLiteral(String),
106    WideCharacterLiteral(String),
107    StringLiteral(String),
108    WideStringLiteral(String),
109    BooleanLiteral(String),
110}
111
112#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
113pub enum IntegerLiteral {
114    BinNumber(String),
115    OctNumber(String),
116    DecNumber(String),
117    HexNumber(String),
118}
119
120#[derive(Debug, Clone, Serialize, Deserialize)]
121pub struct FloatingPtLiteral {
122    pub sign: Option<IntegerSign>,
123    pub integer: DecNumber,
124    pub fraction: DecNumber,
125}
126
127impl<'a> crate::parser::FromTreeSitter<'a> for FloatingPtLiteral {
128    fn from_node(
129        node: tree_sitter::Node<'a>,
130        ctx: &mut crate::parser::ParseContext<'a>,
131    ) -> crate::error::ParserResult<Self> {
132        assert_eq!(
133            node.kind_id(),
134            xidl_parser_derive::node_id!("floating_pt_literal")
135        );
136        let mut sign = None;
137        let mut integer = None;
138        let mut fraction = None;
139        for ch in node.children(&mut node.walk()) {
140            match ch.kind_id() {
141                xidl_parser_derive::node_id!("integer_sign") => {
142                    sign = Some(crate::parser::FromTreeSitter::from_node(ch, ctx)?);
143                }
144                xidl_parser_derive::node_id!("dec_number") => {
145                    let inter = crate::parser::FromTreeSitter::from_node(ch, ctx)?;
146                    if integer.is_none() {
147                        integer = Some(inter);
148                    } else {
149                        fraction = Some(inter);
150                    }
151                }
152
153                _ => {}
154            }
155        }
156        Ok(Self {
157            sign,
158            integer: integer.unwrap(),
159            fraction: fraction.unwrap(),
160        })
161    }
162}
163
164#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
165#[ts(transparent)]
166pub struct IntegerSign(pub String);
167
168#[derive(Debug, Clone, Parser, Serialize, Deserialize)]
169#[ts(transparent)]
170pub struct DecNumber(pub String);
xidl_parser/typed_ast/expr.rs

xidl_parser/typed_ast/
expr.rs
