oak_cpp/ast/
mod.rs

1use core::range::Range;
2
3/// Type alias for source span
4type SourceSpan = Range<usize>;
5
6
7/// Abstract syntax tree for C++ language
8#[derive(Debug, Clone, PartialEq)]
9pub struct CppRoot {
10    pub translation_unit: TranslationUnit,
11}
12
13/// Translation unit (top-level structure of a C++ program)
14#[derive(Debug, Clone, PartialEq)]
15pub struct TranslationUnit {
16    pub external_declarations: Vec<ExternalDeclaration>,
17    pub span: Range<usize>,
18}
19
20/// External declaration
21#[derive(Debug, Clone, PartialEq)]
22pub enum ExternalDeclaration {
23    /// Function definition
24    FunctionDefinition(FunctionDefinition),
25    /// Declaration
26    Declaration(Declaration),
27}
28
29/// Function definition
30#[derive(Debug, Clone, PartialEq)]
31pub struct FunctionDefinition {
32    pub declaration_specifiers: Vec<DeclarationSpecifier>,
33    pub declarator: Declarator,
34    pub compound_statement: CompoundStatement,
35    pub span: SourceSpan,
36}
37
38/// Declaration
39#[derive(Debug, Clone, PartialEq)]
40pub struct Declaration {
41    pub declaration_specifiers: Vec<DeclarationSpecifier>,
42    pub init_declarators: Vec<InitDeclarator>,
43    pub span: SourceSpan,
44}
45
46/// Declaration specifier
47#[derive(Debug, Clone, PartialEq)]
48pub enum DeclarationSpecifier {
49    /// Storage class specifier
50    StorageClassSpecifier(StorageClassSpecifier),
51    /// Type specifier
52    TypeSpecifier(TypeSpecifier),
53    /// Type qualifier
54    TypeQualifier(TypeQualifier),
55    /// Function specifier
56    FunctionSpecifier(FunctionSpecifier),
57}
58
59/// Storage class specifier
60#[derive(Debug, Clone, PartialEq)]
61pub enum StorageClassSpecifier {
62    Typedef,
63    Extern,
64    Static,
65    Auto,
66    Register,
67}
68
69/// Type specifier
70#[derive(Debug, Clone, PartialEq)]
71pub enum TypeSpecifier {
72    Void,
73    Char,
74    Short,
75    Int,
76    Long,
77    Float,
78    Double,
79    Signed,
80    Unsigned,
81    Bool,
82    Complex,
83    Imaginary,
84    StructOrUnion(StructOrUnionSpecifier),
85    Enum(EnumSpecifier),
86    TypedefName(String),
87}
88
89/// Type qualifier
90#[derive(Debug, Clone, PartialEq)]
91pub enum TypeQualifier {
92    Const,
93    Restrict,
94    Volatile,
95}
96
97/// Function specifier
98#[derive(Debug, Clone, PartialEq)]
99pub enum FunctionSpecifier {
100    Inline,
101    Noreturn,
102}
103
104/// Struct or union specifier
105#[derive(Debug, Clone, PartialEq)]
106pub struct StructOrUnionSpecifier {
107    pub struct_or_union: StructOrUnion,
108    pub identifier: Option<String>,
109    pub struct_declarations: Option<Vec<StructDeclaration>>,
110    pub span: SourceSpan,
111}
112
113/// Struct or union
114#[derive(Debug, Clone, PartialEq)]
115pub enum StructOrUnion {
116    Struct,
117    Union,
118}
119
120/// Struct declaration
121#[derive(Debug, Clone, PartialEq)]
122pub struct StructDeclaration {
123    pub specifier_qualifiers: Vec<SpecifierQualifier>,
124    pub struct_declarators: Vec<StructDeclarator>,
125    pub span: SourceSpan,
126}
127
128/// Specifier qualifier
129#[derive(Debug, Clone, PartialEq)]
130pub enum SpecifierQualifier {
131    TypeSpecifier(TypeSpecifier),
132    TypeQualifier(TypeQualifier),
133}
134
135/// Struct declarator
136#[derive(Debug, Clone, PartialEq)]
137pub struct StructDeclarator {
138    pub declarator: Option<Declarator>,
139    pub constant_expression: Option<Expression>,
140    pub span: SourceSpan,
141}
142
143/// Enum specifier
144#[derive(Debug, Clone, PartialEq)]
145pub struct EnumSpecifier {
146    pub identifier: Option<String>,
147    pub enumerators: Option<Vec<Enumerator>>,
148    pub span: SourceSpan,
149}
150
151/// Enumerator
152#[derive(Debug, Clone, PartialEq)]
153pub struct Enumerator {
154    pub identifier: String,
155    pub constant_expression: Option<Expression>,
156    pub span: SourceSpan,
157}
158
159/// Init declarator
160#[derive(Debug, Clone, PartialEq)]
161pub struct InitDeclarator {
162    pub declarator: Declarator,
163    pub initializer: Option<Initializer>,
164    pub span: SourceSpan,
165}
166
167/// Declarator
168#[derive(Debug, Clone, PartialEq)]
169pub struct Declarator {
170    pub pointer: Option<Pointer>,
171    pub direct_declarator: DirectDeclarator,
172    pub span: SourceSpan,
173}
174
175/// Pointer
176#[derive(Debug, Clone, PartialEq)]
177pub struct Pointer {
178    pub type_qualifiers: Vec<TypeQualifier>,
179    pub pointer: Option<Box<Pointer>>,
180    pub span: SourceSpan,
181}
182
183/// Direct declarator
184#[derive(Debug, Clone, PartialEq)]
185pub enum DirectDeclarator {
186    Identifier(String),
187    Declarator(Box<Declarator>),
188    Array {
189        declarator: Box<DirectDeclarator>,
190        assignment_expression: Option<Expression>,
191    },
192    Function {
193        declarator: Box<DirectDeclarator>,
194        parameter_type_list: Option<ParameterTypeList>,
195        identifier_list: Option<Vec<String>>,
196    },
197}
198
199/// Parameter type list
200#[derive(Debug, Clone, PartialEq)]
201pub struct ParameterTypeList {
202    pub parameter_list: Vec<ParameterDeclaration>,
203    pub variadic: bool,
204    pub span: SourceSpan,
205}
206
207/// Parameter declaration
208#[derive(Debug, Clone, PartialEq)]
209pub struct ParameterDeclaration {
210    pub declaration_specifiers: Vec<DeclarationSpecifier>,
211    pub declarator: Option<Declarator>,
212    pub abstract_declarator: Option<AbstractDeclarator>,
213    pub span: SourceSpan,
214}
215
216/// Abstract declarator
217#[derive(Debug, Clone, PartialEq)]
218pub struct AbstractDeclarator {
219    pub pointer: Option<Pointer>,
220    pub direct_abstract_declarator: Option<Box<DirectAbstractDeclarator>>,
221    pub span: Range<usize>,
222}
223
224/// Direct abstract declarator
225#[derive(Debug, Clone, PartialEq)]
226pub enum DirectAbstractDeclarator {
227    AbstractDeclarator(Box<AbstractDeclarator>),
228    Array { declarator: Option<Box<DirectAbstractDeclarator>>, assignment_expression: Option<Box<Expression>> },
229    Function { declarator: Option<Box<DirectAbstractDeclarator>>, parameter_type_list: Option<ParameterTypeList> },
230}
231
232/// Initializer
233#[derive(Debug, Clone, PartialEq)]
234pub enum Initializer {
235    AssignmentExpression(Expression),
236    InitializerList(Vec<Initializer>),
237}
238
239/// Statement
240#[derive(Debug, Clone, PartialEq)]
241pub enum Statement {
242    /// Labeled statement
243    Labeled(LabeledStatement),
244    /// Compound statement
245    Compound(CompoundStatement),
246    /// Expression statement
247    Expression(ExpressionStatement),
248    /// Selection statement
249    Selection(SelectionStatement),
250    /// Iteration statement
251    Iteration(IterationStatement),
252    /// Jump statement
253    Jump(JumpStatement),
254}
255
256/// Labeled statement
257#[derive(Debug, Clone, PartialEq)]
258pub enum LabeledStatement {
259    Label { identifier: String, statement: Box<Statement> },
260    Case { constant_expression: Expression, statement: Box<Statement> },
261    Default { statement: Box<Statement> },
262}
263
264/// Compound statement
265#[derive(Debug, Clone, PartialEq)]
266pub struct CompoundStatement {
267    pub block_items: Vec<BlockItem>,
268    pub span: SourceSpan,
269}
270
271/// Block item
272#[derive(Debug, Clone, PartialEq)]
273pub enum BlockItem {
274    Declaration(Declaration),
275    Statement(Statement),
276}
277
278/// Expression statement
279#[derive(Debug, Clone, PartialEq)]
280pub struct ExpressionStatement {
281    pub expression: Option<Expression>,
282    pub span: SourceSpan,
283}
284
285/// Selection statement
286#[derive(Debug, Clone, PartialEq)]
287pub enum SelectionStatement {
288    If { condition: Expression, then_statement: Box<Statement>, else_statement: Option<Box<Statement>> },
289    Switch { expression: Expression, statement: Box<Statement> },
290}
291
292/// Iteration statement
293#[derive(Debug, Clone, PartialEq)]
294pub enum IterationStatement {
295    While { condition: Expression, statement: Box<Statement> },
296    DoWhile { statement: Box<Statement>, condition: Expression },
297    For { init: Option<Expression>, condition: Option<Expression>, update: Option<Expression>, statement: Box<Statement> },
298}
299
300/// Jump statement
301#[derive(Debug, Clone, PartialEq)]
302pub enum JumpStatement {
303    Goto(String),
304    Continue,
305    Break,
306    Return(Option<Expression>),
307}
308
309/// Expression
310#[derive(Debug, Clone, PartialEq)]
311pub struct Expression {
312    pub kind: Box<ExpressionKind>,
313    pub span: Range<usize>,
314}
315
316/// Expression kind
317#[derive(Debug, Clone, PartialEq)]
318pub enum ExpressionKind {
319    /// Identifier
320    Identifier(String),
321    /// Constant
322    Constant(Constant),
323    /// String literal
324    StringLiteral(String),
325    /// Array subscript
326    ArraySubscript { array: Box<Expression>, index: Box<Expression> },
327    /// Function call
328    FunctionCall { function: Box<Expression>, arguments: Vec<Expression> },
329    /// Member access
330    MemberAccess {
331        object: Box<Expression>,
332        member: String,
333        is_pointer: bool, // true for ->, false for .
334    },
335    /// Postfix increment/decrement
336    PostfixIncDec { operand: Box<Expression>, is_increment: bool },
337    /// Prefix increment/decrement
338    PrefixIncDec { operand: Box<Expression>, is_increment: bool },
339    /// Unary operator
340    Unary { operator: UnaryOperator, operand: Box<Expression> },
341    /// Cast
342    Cast { type_name: Box<TypeName>, expression: Box<Expression> },
343    /// Binary operation
344    Binary { left: Box<Expression>, operator: BinaryOperator, right: Box<Expression> },
345    /// Conditional expression
346    Conditional { condition: Box<Expression>, then_expr: Box<Expression>, else_expr: Box<Expression> },
347    /// Assignment expression
348    Assignment { left: Box<Expression>, operator: AssignmentOperator, right: Box<Expression> },
349    /// Comma expression
350    Comma { expressions: Vec<Expression> },
351}
352
353/// Constant
354#[derive(Debug, Clone, PartialEq)]
355pub enum Constant {
356    Integer(i64),
357    Float(f64),
358    Character(char),
359}
360
361/// Unary operator
362#[derive(Debug, Clone, PartialEq)]
363pub enum UnaryOperator {
364    AddressOf,   // &
365    Dereference, // *
366    Plus,        // +
367    Minus,       // -
368    BitwiseNot,  // ~
369    LogicalNot,  // !
370    Sizeof,      // sizeof
371}
372
373/// Binary operator
374#[derive(Debug, Clone, PartialEq)]
375pub enum BinaryOperator {
376    // Arithmetic operations
377    Add,      // +
378    Subtract, // -
379    Multiply, // *
380    Divide,   // /
381    Modulo,   // %
382
383    // Bitwise operators
384    BitwiseAnd, // &
385    BitwiseOr,  // |
386    BitwiseXor, // ^
387    LeftShift,  // <<
388    RightShift, // >>
389
390    // Comparison operations
391    Equal,        // ==
392    NotEqual,     // !=
393    Less,         // <
394    Greater,      // >
395    LessEqual,    // <=
396    GreaterEqual, // >=
397
398    // Logical operations
399    LogicalAnd, // &&
400    LogicalOr,  // ||
401}
402
403/// Assignment operator
404#[derive(Debug, Clone, PartialEq)]
405pub enum AssignmentOperator {
406    Assign,           // =
407    AddAssign,        // +=
408    SubAssign,        // -=
409    MulAssign,        // *=
410    DivAssign,        // /=
411    ModAssign,        // %=
412    AndAssign,        // &=
413    OrAssign,         // |=
414    XorAssign,        // ^=
415    LeftShiftAssign,  // <<=
416    RightShiftAssign, // >>=
417}
418
419/// Type name
420#[derive(Debug, Clone, PartialEq)]
421pub struct TypeName {
422    pub specifier_qualifiers: Vec<SpecifierQualifier>,
423    pub abstract_declarator: Option<Box<AbstractDeclarator>>,
424    pub span: Range<usize>,
425}
426
427impl TypeName {
428    /// Create a new type name
429    pub fn new(
430        specifier_qualifiers: Vec<SpecifierQualifier>,
431        abstract_declarator: Option<Box<AbstractDeclarator>>,
432        span: Range<usize>,
433    ) -> Self {
434        Self { specifier_qualifiers, abstract_declarator, span }
435    }
436}
437
438impl CppRoot {
439    /// Create a new AST
440    pub fn new(translation_unit: TranslationUnit) -> Self {
441        Self { translation_unit }
442    }
443}
444
445impl TranslationUnit {
446    /// Create a new translation unit
447    pub fn new(external_declarations: Vec<ExternalDeclaration>, span: Range<usize>) -> Self {
448        Self { external_declarations, span }
449    }
450}
oak_cpp/ast/mod.rs

oak_cpp/ast/
mod.rs
