From 97c0ce7419a54e3e3268875c36eff8141f686573 Mon Sep 17 00:00:00 2001 From: Rerumu Date: Wed, 17 Nov 2021 19:57:40 -0500 Subject: [PATCH] De-uglify emit into 1 line --- src/backend/helper/edition.rs | 68 +++++++++++++-------------- src/backend/translation/level_1.rs | 66 +++++++++++++------------- src/backend/translation/level_2.rs | 22 ++++----- src/backend/translation/level_3.rs | 75 +++++++++++++++--------------- 4 files changed, 115 insertions(+), 116 deletions(-) diff --git a/src/backend/helper/edition.rs b/src/backend/helper/edition.rs index b376c2a..577d166 100755 --- a/src/backend/helper/edition.rs +++ b/src/backend/helper/edition.rs @@ -40,30 +40,30 @@ impl Edition for LuaJIT { } fn start_block(&self, w: Writer) -> Result<()> { - writeln!(w, "do") + write!(w, "do ") } fn start_loop(&self, level: usize, w: Writer) -> Result<()> { - writeln!(w, "do")?; - writeln!(w, "::continue_at_{}::", level) + write!(w, "do ")?; + write!(w, "::continue_at_{}::", level) } 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<()> { - writeln!(w, "::continue_at_{}::", level)?; - writeln!(w, "end") + write!(w, "::continue_at_{}::", level)?; + write!(w, "end ") } fn end_loop(&self, w: Writer) -> Result<()> { - writeln!(w, "end") + write!(w, "end ") } fn end_if(&self, level: usize, w: Writer) -> Result<()> { - writeln!(w, "::continue_at_{}::", level)?; - writeln!(w, "end") + write!(w, "::continue_at_{}::", level)?; + write!(w, "end ") } 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<()> { - writeln!(w, "goto continue_at_{}", level - up) + write!(w, "goto continue_at_{} ", level - up) } fn i64(&self, i: i64) -> Infix { @@ -90,63 +90,63 @@ impl Edition for Luau { } 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<()> { - writeln!(w, "while true do") + write!(w, "while true do ") } fn start_if(&self, cond: &str, w: Writer) -> Result<()> { - writeln!(w, "while true do")?; - writeln!(w, "if {} ~= 0 then", cond) + write!(w, "while true do ")?; + write!(w, "if {} ~= 0 then ", cond) } fn end_block(&self, _level: usize, w: Writer) -> Result<()> { - writeln!(w, "break")?; - writeln!(w, "end") + write!(w, "break ")?; + write!(w, "end ") } fn end_loop(&self, w: Writer) -> Result<()> { - writeln!(w, "break")?; - writeln!(w, "end") + write!(w, "break ")?; + write!(w, "end ") } fn end_if(&self, _level: usize, w: Writer) -> Result<()> { - writeln!(w, "end")?; - writeln!(w, "break")?; - writeln!(w, "end") + write!(w, "end ")?; + write!(w, "break ")?; + write!(w, "end ") } fn br_target(&self, level: usize, in_loop: bool, w: Writer) -> Result<()> { - writeln!(w, "if desired then")?; - writeln!(w, "if desired == {} then", level)?; - writeln!(w, "desired = nil")?; + write!(w, "if desired then ")?; + write!(w, "if desired == {} then ", level)?; + write!(w, "desired = nil ")?; if in_loop { - writeln!(w, "continue")?; + write!(w, "continue ")?; } - writeln!(w, "end")?; - writeln!(w, "break")?; - writeln!(w, "end") + write!(w, "end ")?; + write!(w, "break ")?; + write!(w, "end ") } 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 is_loop { - writeln!(w, "continue")?; + write!(w, "continue ")?; } else { - writeln!(w, "break")?; + write!(w, "break ")?; } } else { - writeln!(w, "desired = {}", level - up)?; - writeln!(w, "break")?; + write!(w, "desired = {} ", level - up)?; + write!(w, "break ")?; } - writeln!(w, "end") + write!(w, "end ") } fn i64(&self, i: i64) -> Infix { diff --git a/src/backend/translation/level_1.rs b/src/backend/translation/level_1.rs index 3a858cb..0d83cb9 100644 --- a/src/backend/translation/level_1.rs +++ b/src/backend/translation/level_1.rs @@ -52,28 +52,28 @@ impl<'a> Body<'a> { fn gen_br_if(&mut self, i: u32, f: &Code, w: Writer) -> Result<()> { 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)?; - writeln!(w, "end") + write!(w, "end ") } 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) { if r.len() == 1 { - writeln!(w, "if {} == {} then", case, r.start)?; + write!(w, "if {} == {} then ", reg, r.start)?; } 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)?; write!(w, "else")?; } - writeln!(w)?; + write!(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<()> { @@ -81,20 +81,20 @@ impl<'a> Body<'a> { 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<()> { let val = 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(&mut self, val: T, f: &Code, w: Writer) -> Result<()> { 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<()> { @@ -103,7 +103,7 @@ impl<'a> Body<'a> { 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<()> { @@ -111,7 +111,7 @@ impl<'a> Body<'a> { 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<()> { @@ -120,7 +120,7 @@ impl<'a> Body<'a> { 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<()> { @@ -129,7 +129,7 @@ impl<'a> Body<'a> { 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<()> { @@ -140,15 +140,15 @@ impl<'a> Body<'a> { if a.num_result != 0 { let result = f.var_range_of(bottom, a.num_result).join(", "); - writeln!(w, "{} =", result)?; + write!(w, "{} =", result)?; } if a.num_param == 0 { - writeln!(w, "{}()", name) + write!(w, "{}()", name) } else { 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 - 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<()> { let func = &m.code[index]; match i { - Instruction::Unreachable => writeln!(w, "error('unreachable code entered')"), + Instruction::Unreachable => write!(w, "error('unreachable code entered')"), Instruction::Nop => { // no code Ok(()) @@ -194,7 +194,7 @@ impl<'a> Body<'a> { self.reg.load(); self.reg.save(); - writeln!(w, "else") + write!(w, "else ") } Instruction::End => { let rem = self.label_list.len().saturating_sub(1); @@ -210,7 +210,7 @@ impl<'a> Body<'a> { self.gen_return(num, func, w)?; } - writeln!(w, "end")?; + write!(w, "end ")?; } } @@ -256,21 +256,21 @@ impl<'a> Body<'a> { self.reg.push(1); - writeln!(w, "if {} == 0 then", cond)?; - writeln!(w, "{} = {}", v1, v2)?; - writeln!(w, "end") + write!(w, "if {} == 0 then ", cond)?; + write!(w, "{} = {} ", v1, v2)?; + write!(w, "end ") } Instruction::GetLocal(i) => { let reg = func.var_name_of(self.reg.push(1)); let var = func.var_name_of(*i); - writeln!(w, "{} = {}", reg, var) + write!(w, "{} = {} ", reg, var) } Instruction::SetLocal(i) => { let var = func.var_name_of(*i); let reg = func.var_name_of(self.reg.pop(1)); - writeln!(w, "{} = {}", var, reg) + write!(w, "{} = {} ", var, reg) } Instruction::TeeLocal(i) => { let var = func.var_name_of(*i); @@ -278,17 +278,17 @@ impl<'a> Body<'a> { self.reg.push(1); - writeln!(w, "{} = {}", var, reg) + write!(w, "{} = {} ", var, reg) } Instruction::GetGlobal(i) => { 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) => { 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::I64Load(_, o) => self.gen_load("i64", *o, func, w), @@ -316,14 +316,14 @@ impl<'a> Body<'a> { Instruction::CurrentMemory(index) => { 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) => { let reg = func.var_name_of(self.reg.pop(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::I64Const(v) => self.gen_const(self.spec.i64(*v), func, w), @@ -334,7 +334,7 @@ impl<'a> Body<'a> { 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 => { self.gen_compare("==", func, w) @@ -400,7 +400,7 @@ impl<'a> Body<'a> { 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::F32Floor | Instruction::F64Floor => { diff --git a/src/backend/translation/level_2.rs b/src/backend/translation/level_2.rs index fd1f57d..a5f87a8 100644 --- a/src/backend/translation/level_2.rs +++ b/src/backend/translation/level_2.rs @@ -40,11 +40,11 @@ pub fn gen_init_expression(code: &[Instruction], w: Writer) -> Result<()> { let inst = code.first().unwrap(); match *inst { - Instruction::I32Const(v) => writeln!(w, "{}", v), - Instruction::I64Const(v) => writeln!(w, "{}", v), - Instruction::F32Const(v) => writeln!(w, "{}", f32::from_bits(v)), - Instruction::F64Const(v) => writeln!(w, "{}", f64::from_bits(v)), - Instruction::GetGlobal(i) => writeln!(w, "GLOBAL_LIST[{}].value", i), + Instruction::I32Const(v) => write!(w, "{} ", v), + Instruction::I64Const(v) => write!(w, "{} ", v), + Instruction::F32Const(v) => write!(w, "{} ", f32::from_bits(v)), + Instruction::F64Const(v) => write!(w, "{} ", f64::from_bits(v)), + Instruction::GetGlobal(i) => write!(w, "GLOBAL_LIST[{}].value ", i), _ => 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> { let mut w = Vec::new(); - writeln!(w, "function(")?; + write!(w, "function(")?; write_ordered("param", num_param, &mut w)?; - writeln!(w, ")")?; + write!(w, ")")?; if num_local != 0 { let zero = vec!["0"; num_local as usize].join(", "); - writeln!(w, "local")?; + write!(w, "local ")?; write_ordered("var", num_local, &mut w)?; - writeln!(w, "= {}", zero)?; + write!(w, "= {} ", zero)?; } Ok(w) @@ -72,9 +72,9 @@ fn gen_reg_list(last: u32, num_param: u32, num_local: u32) -> Result> { let num = last - num_local - num_param; if num != 0 { - writeln!(w, "local")?; + write!(w, "local ")?; write_ordered("reg", num, &mut w)?; - writeln!(w)?; + write!(w, " ")?; } Ok(w) diff --git a/src/backend/translation/level_3.rs b/src/backend/translation/level_3.rs index 8e85141..2430523 100755 --- a/src/backend/translation/level_3.rs +++ b/src/backend/translation/level_3.rs @@ -46,7 +46,7 @@ where let field = v.field(); let module = v.module(); - writeln!(w, "{}[{}] = wasm.{}.{}.{}", upper, i, module, lower, field)?; + write!(w, "{}[{}] = wasm.{}.{}.{} ", upper, i, module, lower, field)?; } Ok(()) @@ -68,16 +68,16 @@ where }; let upper = lower.to_uppercase(); - writeln!(w, "{} = {{", lower)?; + write!(w, "{} = {{", lower)?; for v in export.iter().filter(|v| cond(v.internal())) { let field = v.field(); 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<()> { @@ -95,25 +95,25 @@ fn gen_export_list(m: &Module, 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() { - writeln!(w, ", max = {}", max)?; + write!(w, ", max = {}", max)?; } - writeln!(w, ", data = {{}} }}") + write!(w, ", data = {{}} }}") } 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() { - writeln!(w, "{}", max)?; + write!(w, "{}", max)?; } else { - writeln!(w, "nil")?; + write!(w, "nil")?; } - writeln!(w, ")") + write!(w, ")") } 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() { let index = i + offset; - writeln!(w, "TABLE_LIST[{}] =", index)?; + write!(w, "TABLE_LIST[{}] =", index)?; 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() { let index = i + offset; - writeln!(w, "MEMORY_LIST[{}] =", index)?; + write!(w, "MEMORY_LIST[{}] =", index)?; 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() { let index = i + offset; - writeln!(w, "GLOBAL_LIST[{}] = {{ value =", index)?; + write!(w, "GLOBAL_LIST[{}] = {{ value =", index)?; gen_init_expression(v.init_expr().code(), w)?; - writeln!(w, "}}")?; + write!(w, "}}")?; } Ok(()) @@ -175,17 +175,17 @@ fn gen_element_list(m: &Module, w: Writer) -> Result<()> { }; for v in element { - writeln!(w, "do")?; - writeln!(w, "local target = TABLE_LIST[{}].data", v.index())?; - writeln!(w, "local offset =")?; + write!(w, "do ")?; + write!(w, "local target = TABLE_LIST[{}].data ", v.index())?; + write!(w, "local offset =")?; gen_init_expression(v.offset().as_ref().unwrap().code(), w)?; 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(()) @@ -198,9 +198,9 @@ fn gen_data_list(m: &Module, w: Writer) -> Result<()> { }; for v in data { - writeln!(w, "do")?; - writeln!(w, "local target = MEMORY_LIST[{}]", v.index())?; - writeln!(w, "local offset =")?; + write!(w, "do ")?; + write!(w, "local target = MEMORY_LIST[{}]", v.index())?; + write!(w, "local offset =")?; gen_init_expression(v.offset().as_ref().unwrap().code(), w)?; @@ -210,37 +210,36 @@ fn gen_data_list(m: &Module, w: Writer) -> Result<()> { .iter() .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(()) } 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_memory_list(m, w)?; gen_global_list(m, w)?; gen_element_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)?; - writeln!(w, "run_init_code()")?; + write!(w, "run_init_code()")?; 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)?; - - writeln!(w, "}} end") + write!(w, "}} end ") } 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(", "); - writeln!(w, "local {} = {{[0] = {}}}", name, list) + write!(w, "local {} = {{[0] = {}}}", name, list) } pub fn translate(spec: &dyn Edition, m: &Module, w: Writer) -> Result<()> { - writeln!(w, "local rt = require({})", spec.runtime())?; - writeln!(w, "{}", RUNTIME_DATA)?; + write!(w, "local rt = require({})", spec.runtime())?; + write!(w, "{}", RUNTIME_DATA)?; gen_nil_array("FUNC_LIST", m.in_arity.len(), 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(); 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)?; }