oak_wat/ast/
mod.rs

1use oak_core::source::{SourceBuffer, ToSource};
2
3/// Wat 根节点
4#[derive(Clone, Debug)]
5pub struct WatRoot {
6    pub items: Vec<WatItem>,
7}
8
9impl ToSource for WatRoot {
10    fn to_source(&self, buffer: &mut SourceBuffer) {
11        for item in &self.items {
12            item.to_source(buffer);
13            buffer.push("\n");
14        }
15    }
16}
17
18/// Wat 项目
19#[derive(Clone, Debug)]
20pub enum WatItem {
21    Module(WatModule),
22}
23
24impl ToSource for WatItem {
25    fn to_source(&self, buffer: &mut SourceBuffer) {
26        match self {
27            WatItem::Module(m) => m.to_source(buffer),
28        }
29    }
30}
31
32/// Wat 模块
33#[derive(Clone, Debug)]
34pub struct WatModule {
35    pub name: Option<String>,
36    pub items: Vec<WatModuleField>,
37}
38
39impl ToSource for WatModule {
40    fn to_source(&self, buffer: &mut SourceBuffer) {
41        buffer.push("(module");
42        if let Some(name) = &self.name {
43            buffer.push(" ");
44            buffer.push(name);
45        }
46        for item in &self.items {
47            buffer.push("\n  ");
48            item.to_source(buffer);
49        }
50        buffer.push(")");
51    }
52}
53
54/// Wat 模块字段
55#[derive(Clone, Debug)]
56pub enum WatModuleField {
57    Func(WatFunc),
58    Import(WatImport),
59    Export(WatExport),
60    Type(WatType),
61    Table(WatTable),
62    Memory(WatMemory),
63    Global(WatGlobal),
64}
65
66impl ToSource for WatModuleField {
67    fn to_source(&self, buffer: &mut SourceBuffer) {
68        match self {
69            WatModuleField::Func(f) => f.to_source(buffer),
70            WatModuleField::Import(i) => i.to_source(buffer),
71            WatModuleField::Export(e) => e.to_source(buffer),
72            WatModuleField::Type(t) => t.to_source(buffer),
73            WatModuleField::Table(t) => t.to_source(buffer),
74            WatModuleField::Memory(m) => m.to_source(buffer),
75            WatModuleField::Global(g) => g.to_source(buffer),
76        }
77    }
78}
79
80/// Wat 函数
81#[derive(Clone, Debug)]
82pub struct WatFunc {
83    pub name: Option<String>,
84    pub params: Vec<WatParam>,
85    pub results: Vec<WatResult>,
86    pub locals: Vec<WatLocal>,
87    pub body: Vec<WatInstruction>,
88}
89
90impl ToSource for WatFunc {
91    fn to_source(&self, buffer: &mut SourceBuffer) {
92        buffer.push("(func");
93        if let Some(name) = &self.name {
94            buffer.push(" ");
95            buffer.push(name);
96        }
97        for param in &self.params {
98            buffer.push(" ");
99            param.to_source(buffer);
100        }
101        for result in &self.results {
102            buffer.push(" ");
103            result.to_source(buffer);
104        }
105        for local in &self.locals {
106            buffer.push(" ");
107            local.to_source(buffer);
108        }
109        for instr in &self.body {
110            buffer.push("\n    ");
111            instr.to_source(buffer);
112        }
113        buffer.push(")");
114    }
115}
116
117/// Wat 参数
118#[derive(Clone, Debug)]
119pub struct WatParam {
120    pub name: Option<String>,
121    pub ty: WatTypeKind,
122}
123
124impl ToSource for WatParam {
125    fn to_source(&self, buffer: &mut SourceBuffer) {
126        buffer.push("(param");
127        if let Some(name) = &self.name {
128            buffer.push(" ");
129            buffer.push(name);
130        }
131        buffer.push(" ");
132        self.ty.to_source(buffer);
133        buffer.push(")");
134    }
135}
136
137/// Wat 结果
138#[derive(Clone, Debug)]
139pub struct WatResult {
140    pub ty: WatTypeKind,
141}
142
143impl ToSource for WatResult {
144    fn to_source(&self, buffer: &mut SourceBuffer) {
145        buffer.push("(result ");
146        self.ty.to_source(buffer);
147        buffer.push(")");
148    }
149}
150
151/// Wat 局部变量
152#[derive(Clone, Debug)]
153pub struct WatLocal {
154    pub name: Option<String>,
155    pub ty: WatTypeKind,
156}
157
158impl ToSource for WatLocal {
159    fn to_source(&self, buffer: &mut SourceBuffer) {
160        buffer.push("(local");
161        if let Some(name) = &self.name {
162            buffer.push(" ");
163            buffer.push(name);
164        }
165        buffer.push(" ");
166        self.ty.to_source(buffer);
167        buffer.push(")");
168    }
169}
170
171/// Wat 类型种类
172#[derive(Clone, Debug)]
173pub enum WatTypeKind {
174    I32,
175    I64,
176    F32,
177    F64,
178}
179
180impl ToSource for WatTypeKind {
181    fn to_source(&self, buffer: &mut SourceBuffer) {
182        match self {
183            WatTypeKind::I32 => buffer.push("i32"),
184            WatTypeKind::I64 => buffer.push("i64"),
185            WatTypeKind::F32 => buffer.push("f32"),
186            WatTypeKind::F64 => buffer.push("f64"),
187        }
188    }
189}
190
191/// Wat 指令 (简化版)
192#[derive(Clone, Debug)]
193pub struct WatInstruction {
194    pub name: String,
195}
196
197impl ToSource for WatInstruction {
198    fn to_source(&self, buffer: &mut SourceBuffer) {
199        buffer.push(&self.name);
200    }
201}
202
203/// Wat 导入
204#[derive(Clone, Debug)]
205pub struct WatImport {
206    pub module: String,
207    pub field: String,
208}
209
210impl ToSource for WatImport {
211    fn to_source(&self, buffer: &mut SourceBuffer) {
212        buffer.push("(import \"");
213        buffer.push(&self.module);
214        buffer.push("\" \"");
215        buffer.push(&self.field);
216        buffer.push("\")");
217    }
218}
219
220/// Wat 导出
221#[derive(Clone, Debug)]
222pub struct WatExport {
223    pub name: String,
224}
225
226impl ToSource for WatExport {
227    fn to_source(&self, buffer: &mut SourceBuffer) {
228        buffer.push("(export \"");
229        buffer.push(&self.name);
230        buffer.push("\")");
231    }
232}
233
234/// Wat 类型定义
235#[derive(Clone, Debug)]
236pub struct WatType {
237    pub name: Option<String>,
238}
239
240impl ToSource for WatType {
241    fn to_source(&self, buffer: &mut SourceBuffer) {
242        buffer.push("(type");
243        if let Some(name) = &self.name {
244            buffer.push(" ");
245            buffer.push(name);
246        }
247        buffer.push(")");
248    }
249}
250
251/// Wat 表
252#[derive(Clone, Debug)]
253pub struct WatTable {
254    pub name: Option<String>,
255}
256
257impl ToSource for WatTable {
258    fn to_source(&self, buffer: &mut SourceBuffer) {
259        buffer.push("(table");
260        if let Some(name) = &self.name {
261            buffer.push(" ");
262            buffer.push(name);
263        }
264        buffer.push(")");
265    }
266}
267
268/// Wat 内存
269#[derive(Clone, Debug)]
270pub struct WatMemory {
271    pub name: Option<String>,
272}
273
274impl ToSource for WatMemory {
275    fn to_source(&self, buffer: &mut SourceBuffer) {
276        buffer.push("(memory");
277        if let Some(name) = &self.name {
278            buffer.push(" ");
279            buffer.push(name);
280        }
281        buffer.push(")");
282    }
283}
284
285/// Wat 全局变量
286#[derive(Clone, Debug)]
287pub struct WatGlobal {
288    pub name: Option<String>,
289}
290
291impl ToSource for WatGlobal {
292    fn to_source(&self, buffer: &mut SourceBuffer) {
293        buffer.push("(global");
294        if let Some(name) = &self.name {
295            buffer.push(" ");
296            buffer.push(name);
297        }
298        buffer.push(")");
299    }
300}
oak_wat/ast/mod.rs

oak_wat/ast/
mod.rs
