1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
use std::fs;
use std::path::Path;
use crate::util;
use clap::Arg;
use convert_case::{Case, Casing};
use duckscript::types::runtime::{Context, StateValue};
use spacetimedb_lib::type_def::{ReducerDef, TableDef};
use spacetimedb_lib::TupleDef;
use wasmtime::{ExternType, Trap, TypedFunc};
mod code_indenter;
pub mod csharp;
const INDENT: &str = "\t";
pub fn cli() -> clap::Command<'static> {
clap::Command::new("generate")
.about("Generate client files for a spacetime module.")
.arg(
Arg::new("wasm_file")
.takes_value(true)
.required(false)
.long("wasm-file")
.short('w')
.conflicts_with("project_path"),
)
.arg(
Arg::new("project_path")
.takes_value(true)
.required(false)
.long("project-path")
.short('p')
.default_value(".")
.conflicts_with("wasm_file"),
)
.arg(
Arg::new("out_dir")
.takes_value(true)
.required(true)
.long("out-dir")
.short('o'),
)
.arg(
Arg::new("lang")
.takes_value(true)
.required(true)
.long("lang")
.short('l')
.possible_values(["csharp", "cs", "c#"]),
)
.after_help("Run `spacetime help publish` for more detailed information.")
}
pub fn exec(args: &clap::ArgMatches) -> anyhow::Result<()> {
let project_path = args.value_of("project_path").unwrap();
let wasm_file_path = Path::new(project_path);
let mut context = Context::new();
duckscriptsdk::load(&mut context.commands)?;
context
.variables
.insert("PATH".to_string(), std::env::var("PATH").unwrap());
context
.variables
.insert("PROJECT_PATH".to_string(), project_path.to_string());
match duckscript::runner::run_script(include_str!("../project/build.duck"), context) {
Ok(ok) => {
let mut error = false;
for entry in ok.state {
if let StateValue::SubState(sub_state) = entry.1 {
for entry in sub_state {
match entry.1 {
StateValue::String(a) => {
error = true;
println!("{}|{}", entry.0, a)
}
_ => {}
}
}
}
}
if !error {
println!("Build finished successfully.");
} else {
return Err(anyhow::anyhow!(
"Build finished with errors, check the console for more information."
));
}
}
Err(e) => return Err(anyhow::anyhow!(format!("Script execution error: {}", e))),
}
let wasm_file_path = util::find_wasm_file(wasm_file_path)?;
let wasm_file = match args.value_of("wasm_file") {
None => Path::new(wasm_file_path.to_str().unwrap()),
Some(path) => Path::new(path),
};
let out_dir = Path::new(args.value_of("out_dir").unwrap());
let lang = args.value_of("lang").unwrap();
if !out_dir.exists() {
return Err(anyhow::anyhow!(
"Output directory '{}' does not exist. Please create the directory and rerun this command.",
out_dir.to_str().unwrap()
));
}
for (fname, code) in generate(wasm_file, lang)? {
fs::write(out_dir.join(fname), code)?;
}
Ok(())
}
pub fn generate(wasm_file: &Path, lang: &str) -> anyhow::Result<impl Iterator<Item = (String, String)>> {
match lang {
"csharp" | "cs" | "c#" => {
let descriptions = extract_descriptions(&wasm_file)?;
Ok(descriptions.into_iter().map(|(name, desc)| match desc {
Description::Table(table) => {
let code = csharp::autogen_csharp_table(&name, &table);
(name + ".cs", code)
}
Description::Tuple(tup) => {
let code = csharp::autogen_csharp_tuple(&name, &tup);
(name + ".cs", code)
}
Description::Reducer(reducer) => {
let code = csharp::autogen_csharp_reducer(&reducer);
let pascalcase = name.to_case(Case::Pascal);
(pascalcase + "Reducer.cs", code)
}
}))
}
&_ => Err(anyhow::anyhow!(format!("Unsupported langauge: {}", lang))),
}
}
enum Description {
Table(TableDef),
Tuple(TupleDef),
Reducer(ReducerDef),
}
fn extract_descriptions(wasm_file: &Path) -> anyhow::Result<Vec<(String, Description)>> {
let engine = wasmtime::Engine::default();
let module = wasmtime::Module::from_file(&engine, wasm_file)?;
let mut store = wasmtime::Store::new(&engine, ());
let mut linker = wasmtime::Linker::new(&engine);
for imp in module.imports() {
if let ExternType::Func(func_type) = imp.ty() {
linker
.func_new(imp.module(), imp.name(), func_type, |_, _, _| {
Err(Trap::new("don't call me!!"))
})
.unwrap();
}
}
let instance = linker.instantiate(&mut store, &module)?;
let memory = instance.get_memory(&mut store, "memory").unwrap();
let dealloc: TypedFunc<(u32, u32), ()> = instance.get_func(&mut store, "dealloc").unwrap().typed(&store).unwrap();
enum DescrType {
Table,
Tuple,
Reducer,
}
let describes = instance
.exports(&mut store)
.filter_map(|exp| {
let sym = exp.name();
None.or_else(|| sym.strip_prefix("__describe_table__").map(|n| (DescrType::Table, n)))
.or_else(|| sym.strip_prefix("__describe_tuple__").map(|n| (DescrType::Tuple, n)))
.or_else(|| {
sym.strip_prefix("__describe_reducer__")
.map(|n| (DescrType::Reducer, n))
})
.map(|(ty, name)| (ty, name.to_owned(), exp.into_func().unwrap()))
})
.collect::<Vec<_>>();
let mut descriptions = Vec::with_capacity(describes.len());
for (ty, name, describe) in describes {
let describe: TypedFunc<(), (u64,)> = describe.typed(&store).unwrap();
let (val,) = describe.call(&mut store, ()).unwrap();
let offset = (val >> 32) as u32;
let len = (val & 0xFFFF_FFFF) as u32;
let slice = &memory.data(&store)[offset as usize..][..len as usize];
let descr = match ty {
DescrType::Table => Description::Table(TableDef::decode(&mut &slice[..])?),
DescrType::Tuple => Description::Tuple(TupleDef::decode(&mut &slice[..])?),
DescrType::Reducer => Description::Reducer(ReducerDef::decode(&mut &slice[..])?),
};
dealloc.call(&mut store, (offset, len)).unwrap();
descriptions.push((name, descr));
}
Ok(descriptions)
}