Skip to main content

snc_core/
ast.rs

1use crate::error::Span;
2
3/// Top-level AST for an SNL program.
4#[derive(Debug)]
5pub struct Program {
6    pub name: String,
7    pub options: Vec<ProgramOption>,
8    pub definitions: Vec<Definition>,
9    pub entry: Option<Block>,
10    pub state_sets: Vec<StateSet>,
11    pub exit: Option<Block>,
12    pub span: Span,
13}
14
15#[derive(Debug, Clone)]
16pub enum ProgramOption {
17    Safe,      // +s
18    Reentrant, // +r
19    Main,      // +m
20}
21
22/// Top-level definitions (variables, assigns, monitors, etc.)
23#[derive(Debug)]
24pub enum Definition {
25    VarDecl(VarDecl),
26    Assign(Assign),
27    Monitor(Monitor),
28    Sync(Sync),
29    EvFlag(EvFlagDecl),
30    Option(ProgramOption),
31    CPreprocessor(String), // #define, #include, etc. — skip
32    EmbeddedCode(String),  // %%, %{ }%
33}
34
35#[derive(Debug)]
36pub struct VarDecl {
37    pub type_spec: TypeSpec,
38    pub name: String,
39    /// Array dimensions, e.g. `int arr[10]` → `[IntLit(10)]`.
40    pub dimensions: Vec<Expr>,
41    pub init: Option<Expr>,
42    pub span: Span,
43}
44
45#[derive(Debug, Clone, PartialEq, Eq)]
46pub enum TypeSpec {
47    Int,
48    Short,
49    Long,
50    Float,
51    Double,
52    String,
53    Char,
54    Unsigned(Box<TypeSpec>), // unsigned int, etc.
55}
56
57#[derive(Debug)]
58pub struct Assign {
59    pub var_name: String,
60    pub pv_name: Option<String>,
61    pub span: Span,
62}
63
64#[derive(Debug)]
65pub struct Monitor {
66    pub var_name: String,
67    pub span: Span,
68}
69
70#[derive(Debug)]
71pub struct Sync {
72    pub var_name: String,
73    pub ef_name: String,
74    pub span: Span,
75}
76
77#[derive(Debug)]
78pub struct EvFlagDecl {
79    pub name: String,
80    pub span: Span,
81}
82
83#[derive(Debug)]
84pub struct StateSet {
85    pub name: String,
86    pub local_vars: Vec<VarDecl>,
87    pub states: Vec<State>,
88    pub span: Span,
89}
90
91#[derive(Debug)]
92pub struct State {
93    pub name: String,
94    pub entry: Option<Block>,
95    pub transitions: Vec<Transition>,
96    pub exit: Option<Block>,
97    pub span: Span,
98}
99
100#[derive(Debug)]
101pub struct Transition {
102    pub condition: Option<Expr>,
103    pub body: Block,
104    /// Target state name, or None for `exit`.
105    pub target: TransitionTarget,
106    pub span: Span,
107}
108
109#[derive(Debug)]
110pub enum TransitionTarget {
111    State(String),
112    Exit,
113}
114
115/// Expression AST.
116#[derive(Debug)]
117pub enum Expr {
118    IntLit(i64, Span),
119    FloatLit(f64, Span),
120    StringLit(String, Span),
121    Ident(String, Span),
122    BinaryOp(Box<Expr>, BinOp, Box<Expr>, Span),
123    UnaryOp(UnaryOp, Box<Expr>, Span),
124    Call(String, Vec<Expr>, Span),
125    Assign(Box<Expr>, Box<Expr>, Span),
126    CompoundAssign(Box<Expr>, BinOp, Box<Expr>, Span),
127    Field(Box<Expr>, String, Span),
128    Index(Box<Expr>, Box<Expr>, Span),
129    Paren(Box<Expr>, Span),
130    PostIncr(Box<Expr>, Span),
131    PostDecr(Box<Expr>, Span),
132    PreIncr(Box<Expr>, Span),
133    PreDecr(Box<Expr>, Span),
134    Ternary(Box<Expr>, Box<Expr>, Box<Expr>, Span),
135    Cast(TypeSpec, Box<Expr>, Span),
136    ArrayInit(Vec<Expr>, Span),
137}
138
139#[derive(Debug, Clone, Copy, PartialEq, Eq)]
140pub enum BinOp {
141    Add,
142    Sub,
143    Mul,
144    Div,
145    Mod,
146    Eq,
147    Ne,
148    Lt,
149    Le,
150    Gt,
151    Ge,
152    And,
153    Or,
154    BitAnd,
155    BitOr,
156    BitXor,
157    Shl,
158    Shr,
159}
160
161#[derive(Debug, Clone, Copy)]
162pub enum UnaryOp {
163    Neg,
164    Not,
165    BitNot,
166}
167
168/// Statement within a block.
169#[derive(Debug)]
170pub enum Stmt {
171    Expr(Expr),
172    VarDecl(VarDecl),
173    If(Expr, Block, Option<Block>),
174    While(Expr, Block),
175    For(Option<Box<Expr>>, Option<Expr>, Option<Box<Expr>>, Block),
176    Break,
177    Return(Option<Expr>),
178    Block(Block),
179    EmbeddedCode(String),
180}
181
182#[derive(Debug)]
183pub struct Block {
184    pub stmts: Vec<Stmt>,
185    pub span: Span,
186}