code002lover/Wasynth
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

De-uglify emit into 1 line

Browse Source
This commit is contained in:
Rerumu 2021-11-17 19:57:40 -05:00
parent 8b0495d97f
commit 97c0ce7419
4 changed files with 115 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
src/backend/helper/edition.rs
View File

@ -40,30 +40,30 @@ impl Edition for LuaJIT {
} }
fn start_block(&self, w: Writer) -> Result<()> { fn start_block(&self, w: Writer) -> Result<()> {
writeln!(w, "do") write!(w, "do ")
} }
fn start_loop(&self, level: usize, w: Writer) -> Result<()> { fn start_loop(&self, level: usize, w: Writer) -> Result<()> {
writeln!(w, "do")?; write!(w, "do ")?;
writeln!(w, "::continue_at_{}::", level) write!(w, "::continue_at_{}::", level)
} }
fn start_if(&self, cond: &str, w: Writer) -> Result<()> { fn start_if(&self, cond: &str, w: Writer) -> Result<()> {
writeln!(w, "if {} ~= 0 then", cond) write!(w, "if {} ~= 0 then ", cond)
} }
fn end_block(&self, level: usize, w: Writer) -> Result<()> { fn end_block(&self, level: usize, w: Writer) -> Result<()> {
writeln!(w, "::continue_at_{}::", level)?; write!(w, "::continue_at_{}::", level)?;
writeln!(w, "end") write!(w, "end ")
} }
fn end_loop(&self, w: Writer) -> Result<()> { fn end_loop(&self, w: Writer) -> Result<()> {
writeln!(w, "end") write!(w, "end ")
} }
fn end_if(&self, level: usize, w: Writer) -> Result<()> { fn end_if(&self, level: usize, w: Writer) -> Result<()> {
writeln!(w, "::continue_at_{}::", level)?; write!(w, "::continue_at_{}::", level)?;
writeln!(w, "end") write!(w, "end ")
} }
fn br_target(&self, _level: usize, _in_loop: bool, _w: Writer) -> Result<()> { fn br_target(&self, _level: usize, _in_loop: bool, _w: Writer) -> Result<()> {
@ -71,7 +71,7 @@ impl Edition for LuaJIT {
} }
fn br_to_level(&self, level: usize, up: usize, _is_loop: bool, w: Writer) -> Result<()> { fn br_to_level(&self, level: usize, up: usize, _is_loop: bool, w: Writer) -> Result<()> {
writeln!(w, "goto continue_at_{}", level - up) write!(w, "goto continue_at_{} ", level - up)
} }
fn i64(&self, i: i64) -> Infix<i64> { fn i64(&self, i: i64) -> Infix<i64> {
@ -90,63 +90,63 @@ impl Edition for Luau {
} }
fn start_block(&self, w: Writer) -> Result<()> { fn start_block(&self, w: Writer) -> Result<()> {
writeln!(w, "while true do") write!(w, "while true do ")
} }
fn start_loop(&self, _level: usize, w: Writer) -> Result<()> { fn start_loop(&self, _level: usize, w: Writer) -> Result<()> {
writeln!(w, "while true do") write!(w, "while true do ")
} }
fn start_if(&self, cond: &str, w: Writer) -> Result<()> { fn start_if(&self, cond: &str, w: Writer) -> Result<()> {
writeln!(w, "while true do")?; write!(w, "while true do ")?;
writeln!(w, "if {} ~= 0 then", cond) write!(w, "if {} ~= 0 then ", cond)
} }
fn end_block(&self, _level: usize, w: Writer) -> Result<()> { fn end_block(&self, _level: usize, w: Writer) -> Result<()> {
writeln!(w, "break")?; write!(w, "break ")?;
writeln!(w, "end") write!(w, "end ")
} }
fn end_loop(&self, w: Writer) -> Result<()> { fn end_loop(&self, w: Writer) -> Result<()> {
writeln!(w, "break")?; write!(w, "break ")?;
writeln!(w, "end") write!(w, "end ")
} }
fn end_if(&self, _level: usize, w: Writer) -> Result<()> { fn end_if(&self, _level: usize, w: Writer) -> Result<()> {
writeln!(w, "end")?; write!(w, "end ")?;
writeln!(w, "break")?; write!(w, "break ")?;
writeln!(w, "end") write!(w, "end ")
} }
fn br_target(&self, level: usize, in_loop: bool, w: Writer) -> Result<()> { fn br_target(&self, level: usize, in_loop: bool, w: Writer) -> Result<()> {
writeln!(w, "if desired then")?; write!(w, "if desired then ")?;
writeln!(w, "if desired == {} then", level)?; write!(w, "if desired == {} then ", level)?;
writeln!(w, "desired = nil")?; write!(w, "desired = nil ")?;
if in_loop { if in_loop {
writeln!(w, "continue")?; write!(w, "continue ")?;
} }
writeln!(w, "end")?; write!(w, "end ")?;
writeln!(w, "break")?; write!(w, "break ")?;
writeln!(w, "end") write!(w, "end ")
} }
fn br_to_level(&self, level: usize, up: usize, is_loop: bool, w: Writer) -> Result<()> { fn br_to_level(&self, level: usize, up: usize, is_loop: bool, w: Writer) -> Result<()> {
writeln!(w, "do")?; write!(w, "do ")?;
if up == 0 { if up == 0 {
if is_loop { if is_loop {
writeln!(w, "continue")?; write!(w, "continue ")?;
} else { } else {
writeln!(w, "break")?; write!(w, "break ")?;
} }
} else { } else {
writeln!(w, "desired = {}", level - up)?; write!(w, "desired = {} ", level - up)?;
writeln!(w, "break")?; write!(w, "break ")?;
} }
writeln!(w, "end") write!(w, "end ")
} }
fn i64(&self, i: i64) -> Infix<i64> { fn i64(&self, i: i64) -> Infix<i64> {

66
src/backend/translation/level_1.rs
View File

@ -52,28 +52,28 @@ impl<'a> Body<'a> {
fn gen_br_if(&mut self, i: u32, f: &Code, w: Writer) -> Result<()> { fn gen_br_if(&mut self, i: u32, f: &Code, w: Writer) -> Result<()> {
let cond = f.var_name_of(self.reg.pop(1)); let cond = f.var_name_of(self.reg.pop(1));
writeln!(w, "if {} ~= 0 then", cond)?; write!(w, "if {} ~= 0 then ", cond)?;
self.gen_jump(i, w)?; self.gen_jump(i, w)?;
writeln!(w, "end") write!(w, "end ")
} }
fn gen_br_table(&mut self, data: &BrTableData, f: &Code, w: Writer) -> Result<()> { fn gen_br_table(&mut self, data: &BrTableData, f: &Code, w: Writer) -> Result<()> {
let case = f.var_name_of(self.reg.pop(1)); let reg = f.var_name_of(self.reg.pop(1));
for (r, t) in list_to_range(&data.table) { for (r, t) in list_to_range(&data.table) {
if r.len() == 1 { if r.len() == 1 {
writeln!(w, "if {} == {} then", case, r.start)?; write!(w, "if {} == {} then ", reg, r.start)?;
} else { } else {
writeln!(w, "if {0} >= {1} and {0} <= {2} then", case, r.start, r.end)?; write!(w, "if {0} >= {1} and {0} <= {2} then ", reg, r.start, r.end)?;
} }
self.gen_jump(t, w)?; self.gen_jump(t, w)?;
write!(w, "else")?; write!(w, "else")?;
} }
writeln!(w)?; write!(w, " ")?;
self.gen_jump(data.default, w)?; self.gen_jump(data.default, w)?;
writeln!(w, "end") write!(w, "end ")
} }
fn gen_load(&mut self, t: &str, o: u32, f: &Code, w: Writer) -> Result<()> { fn gen_load(&mut self, t: &str, o: u32, f: &Code, w: Writer) -> Result<()> {
@ -81,20 +81,20 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{0} = load.{1}(MEMORY_LIST[0], {0} + {2})", reg, t, o) write!(w, "{0} = load.{1}(MEMORY_LIST[0], {0} + {2}) ", reg, t, o)
} }
fn gen_store(&mut self, t: &str, o: u32, f: &Code, w: Writer) -> Result<()> { fn gen_store(&mut self, t: &str, o: u32, f: &Code, w: Writer) -> Result<()> {
let val = f.var_name_of(self.reg.pop(1)); let val = f.var_name_of(self.reg.pop(1));
let reg = f.var_name_of(self.reg.pop(1)); let reg = f.var_name_of(self.reg.pop(1));
writeln!(w, "store.{}(MEMORY_LIST[0], {} + {}, {})", t, reg, o, val) write!(w, "store.{}(MEMORY_LIST[0], {} + {}, {}) ", t, reg, o, val)
} }
fn gen_const<T: Display>(&mut self, val: T, f: &Code, w: Writer) -> Result<()> { fn gen_const<T: Display>(&mut self, val: T, f: &Code, w: Writer) -> Result<()> {
let reg = f.var_name_of(self.reg.push(1)); let reg = f.var_name_of(self.reg.push(1));
writeln!(w, "{} = {}", reg, val) write!(w, "{} = {} ", reg, val)
} }
fn gen_compare(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> { fn gen_compare(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> {
@ -103,7 +103,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{1} = {1} {0} {2} and 1 or 0", op, lhs, rhs) write!(w, "{1} = {1} {0} {2} and 1 or 0 ", op, lhs, rhs)
} }
fn gen_unop_ex(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> { fn gen_unop_ex(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> {
@ -111,7 +111,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{1} = {0}({1})", op, reg) write!(w, "{1} = {0}({1}) ", op, reg)
} }
fn gen_binop(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> { fn gen_binop(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> {
@ -120,7 +120,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{1} = {1} {0} {2}", op, lhs, rhs) write!(w, "{1} = {1} {0} {2} ", op, lhs, rhs)
} }
fn gen_binop_ex(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> { fn gen_binop_ex(&mut self, op: &str, f: &Code, w: Writer) -> Result<()> {
@ -129,7 +129,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{1} = {0}({1}, {2})", op, lhs, rhs) write!(w, "{1} = {0}({1}, {2}) ", op, lhs, rhs)
} }
fn gen_call(&mut self, name: &str, f: &Code, a: &Arity, w: Writer) -> Result<()> { fn gen_call(&mut self, name: &str, f: &Code, a: &Arity, w: Writer) -> Result<()> {
@ -140,15 +140,15 @@ impl<'a> Body<'a> {
if a.num_result != 0 { if a.num_result != 0 {
let result = f.var_range_of(bottom, a.num_result).join(", "); let result = f.var_range_of(bottom, a.num_result).join(", ");
writeln!(w, "{} =", result)?; write!(w, "{} =", result)?;
} }
if a.num_param == 0 { if a.num_param == 0 {
writeln!(w, "{}()", name) write!(w, "{}()", name)
} else { } else {
let param = f.var_range_of(bottom, a.num_param).join(", "); let param = f.var_range_of(bottom, a.num_param).join(", ");
writeln!(w, "{}({})", name, param) write!(w, "{}({})", name, param)
} }
} }
@ -158,14 +158,14 @@ impl<'a> Body<'a> {
self.reg.pop(num); // technically a no-op self.reg.pop(num); // technically a no-op
writeln!(w, "do return {} end", list) write!(w, "do return {} end ", list)
} }
fn gen_inst(&mut self, index: usize, i: &Instruction, m: &Module, w: Writer) -> Result<()> { fn gen_inst(&mut self, index: usize, i: &Instruction, m: &Module, w: Writer) -> Result<()> {
let func = &m.code[index]; let func = &m.code[index];
match i { match i {
Instruction::Unreachable => writeln!(w, "error('unreachable code entered')"), Instruction::Unreachable => write!(w, "error('unreachable code entered')"),
Instruction::Nop => { Instruction::Nop => {
// no code // no code
Ok(()) Ok(())
@ -194,7 +194,7 @@ impl<'a> Body<'a> {
self.reg.load(); self.reg.load();
self.reg.save(); self.reg.save();
writeln!(w, "else") write!(w, "else ")
} }
Instruction::End => { Instruction::End => {
let rem = self.label_list.len().saturating_sub(1); let rem = self.label_list.len().saturating_sub(1);
@ -210,7 +210,7 @@ impl<'a> Body<'a> {
self.gen_return(num, func, w)?; self.gen_return(num, func, w)?;
} }
writeln!(w, "end")?; write!(w, "end ")?;
} }
} }
@ -256,21 +256,21 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "if {} == 0 then", cond)?; write!(w, "if {} == 0 then ", cond)?;
writeln!(w, "{} = {}", v1, v2)?; write!(w, "{} = {} ", v1, v2)?;
writeln!(w, "end") write!(w, "end ")
} }
Instruction::GetLocal(i) => { Instruction::GetLocal(i) => {
let reg = func.var_name_of(self.reg.push(1)); let reg = func.var_name_of(self.reg.push(1));
let var = func.var_name_of(*i); let var = func.var_name_of(*i);
writeln!(w, "{} = {}", reg, var) write!(w, "{} = {} ", reg, var)
} }
Instruction::SetLocal(i) => { Instruction::SetLocal(i) => {
let var = func.var_name_of(*i); let var = func.var_name_of(*i);
let reg = func.var_name_of(self.reg.pop(1)); let reg = func.var_name_of(self.reg.pop(1));
writeln!(w, "{} = {}", var, reg) write!(w, "{} = {} ", var, reg)
} }
Instruction::TeeLocal(i) => { Instruction::TeeLocal(i) => {
let var = func.var_name_of(*i); let var = func.var_name_of(*i);
@ -278,17 +278,17 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{} = {}", var, reg) write!(w, "{} = {} ", var, reg)
} }
Instruction::GetGlobal(i) => { Instruction::GetGlobal(i) => {
let reg = func.var_name_of(self.reg.push(1)); let reg = func.var_name_of(self.reg.push(1));
writeln!(w, "{} = GLOBAL_LIST[{}].value", reg, i) write!(w, "{} = GLOBAL_LIST[{}].value ", reg, i)
} }
Instruction::SetGlobal(i) => { Instruction::SetGlobal(i) => {
let reg = func.var_name_of(self.reg.pop(1)); let reg = func.var_name_of(self.reg.pop(1));
writeln!(w, "GLOBAL_LIST[{}].value = {}", i, reg) write!(w, "GLOBAL_LIST[{}].value = {} ", i, reg)
} }
Instruction::I32Load(_, o) => self.gen_load("i32", *o, func, w), Instruction::I32Load(_, o) => self.gen_load("i32", *o, func, w),
Instruction::I64Load(_, o) => self.gen_load("i64", *o, func, w), Instruction::I64Load(_, o) => self.gen_load("i64", *o, func, w),
@ -316,14 +316,14 @@ impl<'a> Body<'a> {
Instruction::CurrentMemory(index) => { Instruction::CurrentMemory(index) => {
let reg = func.var_name_of(self.reg.push(1)); let reg = func.var_name_of(self.reg.push(1));
writeln!(w, "{} = rt.memory.size(MEMORY_LIST[{}])", reg, index) write!(w, "{} = rt.memory.size(MEMORY_LIST[{}])", reg, index)
} }
Instruction::GrowMemory(index) => { Instruction::GrowMemory(index) => {
let reg = func.var_name_of(self.reg.pop(1)); let reg = func.var_name_of(self.reg.pop(1));
self.reg.push(1); self.reg.push(1);
writeln!(w, "{0} = rt.memory.grow(MEMORY_LIST[{1}], {0})", reg, index) write!(w, "{0} = rt.memory.grow(MEMORY_LIST[{1}], {0})", reg, index)
} }
Instruction::I32Const(v) => self.gen_const(v, func, w), Instruction::I32Const(v) => self.gen_const(v, func, w),
Instruction::I64Const(v) => self.gen_const(self.spec.i64(*v), func, w), Instruction::I64Const(v) => self.gen_const(self.spec.i64(*v), func, w),
@ -334,7 +334,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{} = {} == 0 and 1 or 0", reg, reg) write!(w, "{} = {} == 0 and 1 or 0 ", reg, reg)
} }
Instruction::I32Eq | Instruction::I64Eq | Instruction::F32Eq | Instruction::F64Eq => { Instruction::I32Eq | Instruction::I64Eq | Instruction::F32Eq | Instruction::F64Eq => {
self.gen_compare("==", func, w) self.gen_compare("==", func, w)
@ -400,7 +400,7 @@ impl<'a> Body<'a> {
self.reg.push(1); self.reg.push(1);
writeln!(w, "{} = -{}", reg, reg) write!(w, "{} = -{} ", reg, reg)
} }
Instruction::F32Ceil | Instruction::F64Ceil => self.gen_unop_ex("math.ceil", func, w), Instruction::F32Ceil | Instruction::F64Ceil => self.gen_unop_ex("math.ceil", func, w),
Instruction::F32Floor | Instruction::F64Floor => { Instruction::F32Floor | Instruction::F64Floor => {

22
src/backend/translation/level_2.rs
View File

@ -40,11 +40,11 @@ pub fn gen_init_expression(code: &[Instruction], w: Writer) -> Result<()> {
let inst = code.first().unwrap(); let inst = code.first().unwrap();
match *inst { match *inst {
Instruction::I32Const(v) => writeln!(w, "{}", v), Instruction::I32Const(v) => write!(w, "{} ", v),
Instruction::I64Const(v) => writeln!(w, "{}", v), Instruction::I64Const(v) => write!(w, "{} ", v),
Instruction::F32Const(v) => writeln!(w, "{}", f32::from_bits(v)), Instruction::F32Const(v) => write!(w, "{} ", f32::from_bits(v)),
Instruction::F64Const(v) => writeln!(w, "{}", f64::from_bits(v)), Instruction::F64Const(v) => write!(w, "{} ", f64::from_bits(v)),
Instruction::GetGlobal(i) => writeln!(w, "GLOBAL_LIST[{}].value", i), Instruction::GetGlobal(i) => write!(w, "GLOBAL_LIST[{}].value ", i),
_ => unreachable!(), _ => unreachable!(),
} }
} }
@ -52,16 +52,16 @@ pub fn gen_init_expression(code: &[Instruction], w: Writer) -> Result<()> {
fn gen_prelude(num_param: u32, num_local: u32) -> Result<Vec<u8>> { fn gen_prelude(num_param: u32, num_local: u32) -> Result<Vec<u8>> {
let mut w = Vec::new(); let mut w = Vec::new();
writeln!(w, "function(")?; write!(w, "function(")?;
write_ordered("param", num_param, &mut w)?; write_ordered("param", num_param, &mut w)?;
writeln!(w, ")")?; write!(w, ")")?;
if num_local != 0 { if num_local != 0 {
let zero = vec!["0"; num_local as usize].join(", "); let zero = vec!["0"; num_local as usize].join(", ");
writeln!(w, "local")?; write!(w, "local ")?;
write_ordered("var", num_local, &mut w)?; write_ordered("var", num_local, &mut w)?;
writeln!(w, "= {}", zero)?; write!(w, "= {} ", zero)?;
} }
Ok(w) Ok(w)
@ -72,9 +72,9 @@ fn gen_reg_list(last: u32, num_param: u32, num_local: u32) -> Result<Vec<u8>> {
let num = last - num_local - num_param; let num = last - num_local - num_param;
if num != 0 { if num != 0 {
writeln!(w, "local")?; write!(w, "local ")?;
write_ordered("reg", num, &mut w)?; write_ordered("reg", num, &mut w)?;
writeln!(w)?; write!(w, " ")?;
} }
Ok(w) Ok(w)

75
src/backend/translation/level_3.rs
View File

@ -46,7 +46,7 @@ where
let field = v.field(); let field = v.field();
let module = v.module(); let module = v.module();
writeln!(w, "{}[{}] = wasm.{}.{}.{}", upper, i, module, lower, field)?; write!(w, "{}[{}] = wasm.{}.{}.{} ", upper, i, module, lower, field)?;
} }
Ok(()) Ok(())
@ -68,16 +68,16 @@ where
}; };
let upper = lower.to_uppercase(); let upper = lower.to_uppercase();
writeln!(w, "{} = {{", lower)?; write!(w, "{} = {{", lower)?;
for v in export.iter().filter(|v| cond(v.internal())) { for v in export.iter().filter(|v| cond(v.internal())) {
let field = v.field(); let field = v.field();
let index = aux_internal_index(*v.internal()); let index = aux_internal_index(*v.internal());
writeln!(w, "{} = {}[{}],", field, upper, index)?; write!(w, "{} = {}[{}],", field, upper, index)?;
} }
writeln!(w, "}},") write!(w, "}},")
} }
fn gen_import_list(m: &Module, w: Writer) -> Result<()> { fn gen_import_list(m: &Module, w: Writer) -> Result<()> {
@ -95,25 +95,25 @@ fn gen_export_list(m: &Module, w: Writer) -> Result<()> {
} }
fn gen_table_init(limit: &ResizableLimits, w: Writer) -> Result<()> { fn gen_table_init(limit: &ResizableLimits, w: Writer) -> Result<()> {
writeln!(w, "{{ min = {}", limit.initial())?; write!(w, "{{ min = {}", limit.initial())?;
if let Some(max) = limit.maximum() { if let Some(max) = limit.maximum() {
writeln!(w, ", max = {}", max)?; write!(w, ", max = {}", max)?;
} }
writeln!(w, ", data = {{}} }}") write!(w, ", data = {{}} }}")
} }
fn gen_memory_init(limit: &ResizableLimits, w: Writer) -> Result<()> { fn gen_memory_init(limit: &ResizableLimits, w: Writer) -> Result<()> {
writeln!(w, "rt.memory.new({}, ", limit.initial())?; write!(w, "rt.memory.new({}, ", limit.initial())?;
if let Some(max) = limit.maximum() { if let Some(max) = limit.maximum() {
writeln!(w, "{}", max)?; write!(w, "{}", max)?;
} else { } else {
writeln!(w, "nil")?; write!(w, "nil")?;
} }
writeln!(w, ")") write!(w, ")")
} }
fn gen_table_list(m: &Module, w: Writer) -> Result<()> { fn gen_table_list(m: &Module, w: Writer) -> Result<()> {
@ -126,7 +126,7 @@ fn gen_table_list(m: &Module, w: Writer) -> Result<()> {
for (i, v) in table.iter().enumerate() { for (i, v) in table.iter().enumerate() {
let index = i + offset; let index = i + offset;
writeln!(w, "TABLE_LIST[{}] =", index)?; write!(w, "TABLE_LIST[{}] =", index)?;
gen_table_init(v.limits(), w)?; gen_table_init(v.limits(), w)?;
} }
@ -143,7 +143,7 @@ fn gen_memory_list(m: &Module, w: Writer) -> Result<()> {
for (i, v) in memory.iter().enumerate() { for (i, v) in memory.iter().enumerate() {
let index = i + offset; let index = i + offset;
writeln!(w, "MEMORY_LIST[{}] =", index)?; write!(w, "MEMORY_LIST[{}] =", index)?;
gen_memory_init(v.limits(), w)?; gen_memory_init(v.limits(), w)?;
} }
@ -160,9 +160,9 @@ fn gen_global_list(m: &Module, w: Writer) -> Result<()> {
for (i, v) in global.entries().iter().enumerate() { for (i, v) in global.entries().iter().enumerate() {
let index = i + offset; let index = i + offset;
writeln!(w, "GLOBAL_LIST[{}] = {{ value =", index)?; write!(w, "GLOBAL_LIST[{}] = {{ value =", index)?;
gen_init_expression(v.init_expr().code(), w)?; gen_init_expression(v.init_expr().code(), w)?;
writeln!(w, "}}")?; write!(w, "}}")?;
} }
Ok(()) Ok(())
@ -175,17 +175,17 @@ fn gen_element_list(m: &Module, w: Writer) -> Result<()> {
}; };
for v in element { for v in element {
writeln!(w, "do")?; write!(w, "do ")?;
writeln!(w, "local target = TABLE_LIST[{}].data", v.index())?; write!(w, "local target = TABLE_LIST[{}].data ", v.index())?;
writeln!(w, "local offset =")?; write!(w, "local offset =")?;
gen_init_expression(v.offset().as_ref().unwrap().code(), w)?; gen_init_expression(v.offset().as_ref().unwrap().code(), w)?;
for (i, f) in v.members().iter().enumerate() { for (i, f) in v.members().iter().enumerate() {
writeln!(w, "target[offset + {}] = FUNC_LIST[{}]", i, f)?; write!(w, "target[offset + {}] = FUNC_LIST[{}]", i, f)?;
} }
writeln!(w, "end")?; write!(w, "end ")?;
} }
Ok(()) Ok(())
@ -198,9 +198,9 @@ fn gen_data_list(m: &Module, w: Writer) -> Result<()> {
}; };
for v in data { for v in data {
writeln!(w, "do")?; write!(w, "do ")?;
writeln!(w, "local target = MEMORY_LIST[{}]", v.index())?; write!(w, "local target = MEMORY_LIST[{}]", v.index())?;
writeln!(w, "local offset =")?; write!(w, "local offset =")?;
gen_init_expression(v.offset().as_ref().unwrap().code(), w)?; gen_init_expression(v.offset().as_ref().unwrap().code(), w)?;
@ -210,37 +210,36 @@ fn gen_data_list(m: &Module, w: Writer) -> Result<()> {
.iter() .iter()
.try_for_each(|v| write!(w, "\\x{:02X}", v))?; .try_for_each(|v| write!(w, "\\x{:02X}", v))?;
writeln!(w, "\"")?; write!(w, "\"")?;
writeln!(w, "rt.memory.init(target, offset, data)",)?; write!(w, "rt.memory.init(target, offset, data)")?;
writeln!(w, "end")?; write!(w, "end ")?;
} }
Ok(()) Ok(())
} }
fn gen_start_point(m: &Module, w: Writer) -> Result<()> { fn gen_start_point(m: &Module, w: Writer) -> Result<()> {
writeln!(w, "local function run_init_code()")?; write!(w, "local function run_init_code()")?;
gen_table_list(m, w)?; gen_table_list(m, w)?;
gen_memory_list(m, w)?; gen_memory_list(m, w)?;
gen_global_list(m, w)?; gen_global_list(m, w)?;
gen_element_list(m, w)?; gen_element_list(m, w)?;
gen_data_list(m, w)?; gen_data_list(m, w)?;
writeln!(w, "end")?; write!(w, "end ")?;
writeln!(w, "return function(wasm)")?; write!(w, "return function(wasm)")?;
gen_import_list(m, w)?; gen_import_list(m, w)?;
writeln!(w, "run_init_code()")?; write!(w, "run_init_code()")?;
if let Some(start) = m.parent.start_section() { if let Some(start) = m.parent.start_section() {
writeln!(w, "FUNC_LIST[{}]()", start)?; write!(w, "FUNC_LIST[{}]()", start)?;
} }
writeln!(w, "return {{")?; write!(w, "return {{")?;
gen_export_list(m, w)?; gen_export_list(m, w)?;
write!(w, "}} end ")
writeln!(w, "}} end")
} }
fn gen_nil_array(name: &str, len: usize, w: Writer) -> Result<()> { fn gen_nil_array(name: &str, len: usize, w: Writer) -> Result<()> {
@ -250,12 +249,12 @@ fn gen_nil_array(name: &str, len: usize, w: Writer) -> Result<()> {
let list = vec!["nil"; len].join(", "); let list = vec!["nil"; len].join(", ");
writeln!(w, "local {} = {{[0] = {}}}", name, list) write!(w, "local {} = {{[0] = {}}}", name, list)
} }
pub fn translate(spec: &dyn Edition, m: &Module, w: Writer) -> Result<()> { pub fn translate(spec: &dyn Edition, m: &Module, w: Writer) -> Result<()> {
writeln!(w, "local rt = require({})", spec.runtime())?; write!(w, "local rt = require({})", spec.runtime())?;
writeln!(w, "{}", RUNTIME_DATA)?; write!(w, "{}", RUNTIME_DATA)?;
gen_nil_array("FUNC_LIST", m.in_arity.len(), w)?; gen_nil_array("FUNC_LIST", m.in_arity.len(), w)?;
gen_nil_array("TABLE_LIST", m.parent.table_space(), w)?; gen_nil_array("TABLE_LIST", m.parent.table_space(), w)?;
@ -265,7 +264,7 @@ pub fn translate(spec: &dyn Edition, m: &Module, w: Writer) -> Result<()> {
let offset = m.ex_arity.len(); let offset = m.ex_arity.len();
for i in 0..m.in_arity.len() { for i in 0..m.in_arity.len() {
writeln!(w, "FUNC_LIST[{}] =", i + offset)?; write!(w, "FUNC_LIST[{}] =", i + offset)?;
gen_function(spec, i, m, w)?; gen_function(spec, i, m, w)?;
} }