gobject_ast/model/
operators.rs

1use serde::Serialize;
2
3/// Binary operators in C
4#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
5#[serde(rename_all = "snake_case")]
6pub enum BinaryOp {
7    // Arithmetic
8    Add,      // +
9    Subtract, // -
10    Multiply, // *
11    Divide,   // /
12    Modulo,   // %
13
14    // Comparison
15    Equal,        // ==
16    NotEqual,     // !=
17    Less,         // <
18    LessEqual,    // <=
19    Greater,      // >
20    GreaterEqual, // >=
21
22    // Logical
23    LogicalAnd, // &&
24    LogicalOr,  // ||
25
26    // Bitwise
27    BitwiseAnd, // &
28    BitwiseOr,  // |
29    BitwiseXor, // ^
30    LeftShift,  // <<
31    RightShift, // >>
32}
33
34impl BinaryOp {
35    /// Parse from operator string
36    pub fn parse(s: &str) -> Option<Self> {
37        match s {
38            "+" => Some(Self::Add),
39            "-" => Some(Self::Subtract),
40            "*" => Some(Self::Multiply),
41            "/" => Some(Self::Divide),
42            "%" => Some(Self::Modulo),
43            "==" => Some(Self::Equal),
44            "!=" => Some(Self::NotEqual),
45            "<" => Some(Self::Less),
46            "<=" => Some(Self::LessEqual),
47            ">" => Some(Self::Greater),
48            ">=" => Some(Self::GreaterEqual),
49            "&&" => Some(Self::LogicalAnd),
50            "||" => Some(Self::LogicalOr),
51            "&" => Some(Self::BitwiseAnd),
52            "|" => Some(Self::BitwiseOr),
53            "^" => Some(Self::BitwiseXor),
54            "<<" => Some(Self::LeftShift),
55            ">>" => Some(Self::RightShift),
56            _ => None,
57        }
58    }
59
60    /// Convert to operator string
61    pub fn as_str(&self) -> &'static str {
62        match self {
63            Self::Add => "+",
64            Self::Subtract => "-",
65            Self::Multiply => "*",
66            Self::Divide => "/",
67            Self::Modulo => "%",
68            Self::Equal => "==",
69            Self::NotEqual => "!=",
70            Self::Less => "<",
71            Self::LessEqual => "<=",
72            Self::Greater => ">",
73            Self::GreaterEqual => ">=",
74            Self::LogicalAnd => "&&",
75            Self::LogicalOr => "||",
76            Self::BitwiseAnd => "&",
77            Self::BitwiseOr => "|",
78            Self::BitwiseXor => "^",
79            Self::LeftShift => "<<",
80            Self::RightShift => ">>",
81        }
82    }
83
84    /// Check if this is a comparison operator
85    pub fn is_comparison(&self) -> bool {
86        matches!(
87            self,
88            Self::Equal
89                | Self::NotEqual
90                | Self::Less
91                | Self::LessEqual
92                | Self::Greater
93                | Self::GreaterEqual
94        )
95    }
96}
97
98/// Unary operators in C
99#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
100#[serde(rename_all = "snake_case")]
101pub enum UnaryOp {
102    Not,           // !
103    BitwiseNot,    // ~
104    Negate,        // - (unary minus)
105    Plus,          // + (unary plus)
106    Dereference,   // *
107    AddressOf,     // &
108    PreIncrement,  // ++x (handled by UpdateExpression but can appear)
109    PreDecrement,  // --x (handled by UpdateExpression but can appear)
110    PostIncrement, // x++ (handled by UpdateExpression but can appear)
111    PostDecrement, // x-- (handled by UpdateExpression but can appear)
112}
113
114impl UnaryOp {
115    /// Parse from operator string
116    pub fn parse(s: &str) -> Option<Self> {
117        match s {
118            "!" => Some(Self::Not),
119            "~" => Some(Self::BitwiseNot),
120            "-" => Some(Self::Negate),
121            "+" => Some(Self::Plus),
122            "*" => Some(Self::Dereference),
123            "&" => Some(Self::AddressOf),
124            "++" => Some(Self::PreIncrement),
125            "--" => Some(Self::PreDecrement),
126            _ => None,
127        }
128    }
129
130    /// Convert to operator string
131    pub fn as_str(&self) -> &'static str {
132        match self {
133            Self::Not => "!",
134            Self::BitwiseNot => "~",
135            Self::Negate => "-",
136            Self::Plus => "+",
137            Self::Dereference => "*",
138            Self::AddressOf => "&",
139            Self::PreIncrement | Self::PostIncrement => "++",
140            Self::PreDecrement | Self::PostDecrement => "--",
141        }
142    }
143}
144
145/// Update operators (increment/decrement)
146#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
147#[serde(rename_all = "snake_case")]
148pub enum UpdateOp {
149    Increment, // ++
150    Decrement, // --
151}
152
153impl UpdateOp {
154    /// Parse from operator string
155    pub fn parse(s: &str) -> Option<Self> {
156        match s {
157            "++" => Some(Self::Increment),
158            "--" => Some(Self::Decrement),
159            _ => None,
160        }
161    }
162
163    /// Convert to operator string
164    pub fn as_str(&self) -> &'static str {
165        match self {
166            Self::Increment => "++",
167            Self::Decrement => "--",
168        }
169    }
170}
171
172/// Assignment operators in C
173#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
174#[serde(rename_all = "snake_case")]
175pub enum AssignmentOp {
176    Assign,           // =
177    AddAssign,        // +=
178    SubtractAssign,   // -=
179    MultiplyAssign,   // *=
180    DivideAssign,     // /=
181    ModuloAssign,     // %=
182    BitwiseAndAssign, // &=
183    BitwiseOrAssign,  // |=
184    BitwiseXorAssign, // ^=
185    LeftShiftAssign,  // <<=
186    RightShiftAssign, // >>=
187}
188
189impl AssignmentOp {
190    /// Parse from operator string
191    pub fn parse(s: &str) -> Option<Self> {
192        match s {
193            "=" => Some(Self::Assign),
194            "+=" => Some(Self::AddAssign),
195            "-=" => Some(Self::SubtractAssign),
196            "*=" => Some(Self::MultiplyAssign),
197            "/=" => Some(Self::DivideAssign),
198            "%=" => Some(Self::ModuloAssign),
199            "&=" => Some(Self::BitwiseAndAssign),
200            "|=" => Some(Self::BitwiseOrAssign),
201            "^=" => Some(Self::BitwiseXorAssign),
202            "<<=" => Some(Self::LeftShiftAssign),
203            ">>=" => Some(Self::RightShiftAssign),
204            _ => None,
205        }
206    }
207
208    /// Convert to operator string
209    pub fn as_str(&self) -> &'static str {
210        match self {
211            Self::Assign => "=",
212            Self::AddAssign => "+=",
213            Self::SubtractAssign => "-=",
214            Self::MultiplyAssign => "*=",
215            Self::DivideAssign => "/=",
216            Self::ModuloAssign => "%=",
217            Self::BitwiseAndAssign => "&=",
218            Self::BitwiseOrAssign => "|=",
219            Self::BitwiseXorAssign => "^=",
220            Self::LeftShiftAssign => "<<=",
221            Self::RightShiftAssign => ">>=",
222        }
223    }
224}
225
226/// Field access operators in C
227#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
228#[serde(rename_all = "snake_case")]
229pub enum FieldAccessOp {
230    Arrow, // ->
231    Dot,   // .
232}
233
234impl FieldAccessOp {
235    /// Parse from operator string
236    pub fn parse(s: &str) -> Option<Self> {
237        match s {
238            "->" => Some(Self::Arrow),
239            "." => Some(Self::Dot),
240            _ => None,
241        }
242    }
243
244    /// Convert to operator string
245    pub fn as_str(&self) -> &'static str {
246        match self {
247            Self::Arrow => "->",
248            Self::Dot => ".",
249        }
250    }
251}
gobject_ast/model/operators.rs

gobject_ast/model/
operators.rs
