1use crate::error::Span;
2
3#[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, Reentrant, Main, }
21
22#[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), EmbeddedCode(String), }
34
35#[derive(Debug)]
36pub struct VarDecl {
37 pub type_spec: TypeSpec,
38 pub name: String,
39 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>), }
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 pub target: TransitionTarget,
106 pub span: Span,
107}
108
109#[derive(Debug)]
110pub enum TransitionTarget {
111 State(String),
112 Exit,
113}
114
115#[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#[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}