Enum CNode 

pub enum CNode {
    TranslationUnit(Vec<CNode>),
    FuncDef {
        return_type: CType,
        name: String,
        params: Vec<(CType, String)>,
        body: Vec<CNode>,
    },
    VarDecl {
        var_type: CType,
        name: String,
        init: Option<Box<CNode>>,
    },
    Assign {
        lhs: Box<CNode>,
        rhs: Box<CNode>,
    },
    BinOp {
        left: Box<CNode>,
        op: CBinaryOp,
        right: Box<CNode>,
    },
    UnaryOp {
        op: CUnaryOp,
        operand: Box<CNode>,
    },
    IntLit(i64),
    FloatLit(f64),
    CharLit(char),
    StrLit(String),
    Ident(String),
    If {
        cond: Box<CNode>,
        then_body: Vec<CNode>,
        else_body: Vec<CNode>,
    },
    While {
        cond: Box<CNode>,
        body: Vec<CNode>,
    },
    For {
        init: Option<Box<CNode>>,
        cond: Option<Box<CNode>>,
        incr: Option<Box<CNode>>,
        body: Vec<CNode>,
    },
    Return(Option<Box<CNode>>),
    Break,
    Continue,
    Call {
        func: String,
        args: Vec<CNode>,
    },
    ArrayAccess {
        array: Box<CNode>,
        index: Box<CNode>,
    },
    Compare {
        left: Box<CNode>,
        op: CCompareOp,
        right: Box<CNode>,
    },
    ExprStmt(Box<CNode>),
    Block(Vec<CNode>),
    Ternary {
        cond: Box<CNode>,
        then_expr: Box<CNode>,
        else_expr: Box<CNode>,
    },
    Sizeof(CType),
    Cast {
        target_type: CType,
        expr: Box<CNode>,
    },
    Deref(Box<CNode>),
    AddrOf(Box<CNode>),
    StructAccess {
        expr: Box<CNode>,
        field: String,
    },
    PtrAccess {
        expr: Box<CNode>,
        field: String,
    },
    Increment {
        operand: Box<CNode>,
        pre: bool,
    },
    Decrement {
        operand: Box<CNode>,
        pre: bool,
    },
}

C AST node types for generation

Variants

TranslationUnit(Vec<CNode>)

Translation unit (root node)

FuncDef

Function definition

Fields

return_type: CType

Return type

name: String

Function name

params: Vec<(CType, String)>

Parameters

body: Vec<CNode>

Function body

VarDecl

Variable declaration

Fields

var_type: CType

Variable type

name: String

Variable name

init: Option<Box<CNode>>

Optional initializer

Assign

Assignment: lhs = rhs

Fields

lhs: Box<CNode>

Left-hand side

rhs: Box<CNode>

Right-hand side

BinOp

Binary operation

Fields

left: Box<CNode>

Left operand

op: CBinaryOp

Operator

right: Box<CNode>

Right operand

UnaryOp

Unary operation

Fields

op: CUnaryOp

Operator

operand: Box<CNode>

Operand

IntLit(i64)

Integer literal

FloatLit(f64)

Float literal

CharLit(char)

Character literal

StrLit(String)

String literal

Ident(String)

Variable reference

If

If statement

Fields

cond: Box<CNode>

Condition

then_body: Vec<CNode>

Then body

else_body: Vec<CNode>

Else body

While

While loop

Fields

cond: Box<CNode>

Condition

body: Vec<CNode>

Loop body

For

For loop

Fields

init: Option<Box<CNode>>

Initialization

cond: Option<Box<CNode>>

Condition

incr: Option<Box<CNode>>

Increment

body: Vec<CNode>

Loop body

Return(Option<Box<CNode>>)

Return statement

Break

Break statement

Continue

Continue statement

Call

Function call

Fields

func: String

Function name

args: Vec<CNode>

Arguments

ArrayAccess

Array access

Fields

array: Box<CNode>

Array expression

index: Box<CNode>

Index expression

Compare

Comparison operation

Fields

left: Box<CNode>

Left operand

op: CCompareOp

Operator

right: Box<CNode>

Right operand

ExprStmt(Box<CNode>)

Expression statement

Block(Vec<CNode>)

Compound statement (block)

Ternary

Ternary operator: cond ? then : else

Fields

cond: Box<CNode>

Condition

then_expr: Box<CNode>

Then expression

else_expr: Box<CNode>

Else expression

Sizeof(CType)

Sizeof expression

Cast

Cast expression

Fields

target_type: CType

Target type

expr: Box<CNode>

Expression

Deref(Box<CNode>)

Pointer dereference

AddrOf(Box<CNode>)

Address-of

StructAccess

Struct access: expr.field

Fields

expr: Box<CNode>

Expression

field: String

Field name

PtrAccess

Pointer struct access: expr->field

Fields

expr: Box<CNode>

Expression

field: String

Field name

Increment

Increment: ++x or x++

Fields

operand: Box<CNode>

Operand

pre: bool

Pre-increment (++x) or post-increment (x++)

Decrement

Decrement: --x or x--

Fields

operand: Box<CNode>

Operand

pre: bool

Pre-decrement (–x) or post-decrement (x–)

Implementations

impl CNode

pub fn to_code(&self, indent: usize) -> String

Convert AST node to C code string

pub fn depth(&self) -> usize

Calculate AST depth

Trait Implementations

impl Clone for CNode

fn clone(&self) -> CNode

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CNode

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CNode

fn eq(&self, other: &CNode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for CNode