use super::flow::{
binop, conv, paren_if_needed, restructure_do_while_loops, restructure_for_loops,
restructure_if_else, restructure_switch, restructure_while_loops, strip_outer_parens, unop,
};
use crate::cil::decoder::{decode, Instruction, Operand};
use crate::error::Result;
use crate::metadata::reader::Reader;
use crate::metadata::signatures::{MethodSig, Type};
use crate::metadata::tables::{Coded, CodedIndex, tbl};
#[derive(Debug, Clone)]
pub struct DecompiledType {
pub file_name: String,
pub source: String,
}
pub fn decompile_assembly(reader: &Reader<'_>) -> Result<Vec<DecompiledType>> {
let mut out = Vec::new();
let type_defs = reader.tables.get(tbl::TYPEDEF);
for (i, row) in type_defs.iter().enumerate() {
let row_idx = (i + 1) as u32;
let name = reader.type_def_name(row);
if name == "<Module>" {
continue;
}
if reader.nested_parent(row_idx).is_some() {
continue;
}
let source = decompile_type(reader, row_idx)?;
let ns = reader.type_def_namespace(row);
let file_name = file_name_for(&ns, &name);
out.push(DecompiledType { file_name, source });
}
Ok(out)
}
pub fn decompile_type_by_name(reader: &Reader<'_>, query: &str) -> Result<Option<DecompiledType>> {
let type_defs = reader.tables.get(tbl::TYPEDEF);
for (i, row) in type_defs.iter().enumerate() {
let row_idx = (i + 1) as u32;
let name = reader.type_def_name(row);
if name == "<Module>" {
continue;
}
let ns = reader.type_def_namespace(row);
let full = if ns.is_empty() {
name.clone()
} else {
format!("{ns}.{name}")
};
if name == query || full == query {
if reader.nested_parent(row_idx).is_some() {
continue;
}
let source = decompile_type(reader, row_idx)?;
let file_name = file_name_for(&ns, &name);
return Ok(Some(DecompiledType { file_name, source }));
}
}
Ok(None)
}
fn file_name_for(ns: &str, name: &str) -> String {
let clean = name.replace(['`', '/', '\\'], "_");
if ns.is_empty() {
format!("{clean}.cs")
} else {
format!("{}_{clean}.cs", ns.replace('.', "_"))
}
}
fn decompile_type(reader: &Reader<'_>, row_idx: u32) -> Result<String> {
let row = &reader.tables.get(tbl::TYPEDEF)[row_idx as usize - 1];
let flags = row.col(0);
let name = reader.type_def_name(row);
let ns = reader.type_def_namespace(row);
let extends = reader.type_def_extends(row);
let access = type_access(flags);
let is_interface = flags & 0x00000020 != 0;
let is_abstract = flags & 0x00000080 != 0;
let is_sealed = flags & 0x00000100 != 0;
let base_full = base_type_name(reader, extends).unwrap_or_default();
let base_simple = strip_system(&base_full);
let is_struct = base_simple == "ValueType";
let is_enum = base_simple == "Enum";
let is_delegate = base_simple == "MulticastDelegate";
let kind = if is_interface {
"interface"
} else if is_enum {
"enum"
} else if is_struct {
"struct"
} else {
"class"
};
let generics = reader.generic_params_for(CodedIndex { table: Some(tbl::TYPEDEF), row: row_idx });
let class_generic_names: Vec<String> = generics.iter().map(|(_, n)| n.clone()).collect();
let generic_decl = if class_generic_names.is_empty() {
String::new()
} else {
format!("<{}>", class_generic_names.join(", "))
};
let mut s = String::new();
let usings = reader.external_namespaces();
for u in &usings {
s.push_str(&format!("using {u};\n"));
}
if !usings.is_empty() {
s.push('\n');
}
if !ns.is_empty() {
s.push_str(&format!("namespace {ns};\n\n"));
}
let type_attrs = reader.custom_attributes_with_args_for(tbl::TYPEDEF, row_idx);
for (name, args) in &type_attrs {
s.push_str(&format!(" {}\n", format_attr_line(name, args)));
}
let mut keywords = Vec::new();
let has_instance_ctor = reader.type_method_rows(row_idx).any(|mi| {
let m = &reader.tables.get(tbl::METHODDEF)[mi];
reader.method_name(m) == ".ctor" && reader.method_flags(m) & 0x0010 == 0
});
let is_static_class = is_abstract
&& is_sealed
&& !is_interface
&& !is_struct
&& !is_enum
&& !is_delegate
&& !has_instance_ctor;
if !access.is_empty() {
keywords.push(access.to_string());
}
if is_static_class {
keywords.push("static".into());
} else {
if is_abstract && !is_interface && !is_struct && !is_delegate {
keywords.push("abstract".into());
}
if is_sealed && !is_interface && !is_struct && !is_enum && !is_delegate {
keywords.push("sealed".into());
}
}
keywords.push(kind.to_string());
if is_delegate {
let method_range = reader.type_method_rows(row_idx);
let invoke = method_range.clone().find_map(|mi| {
let m = &reader.tables.get(tbl::METHODDEF)[mi];
if reader.method_name(m) == "Invoke" {
reader.method_sig(m).ok().map(|sig| (sig, mi))
} else {
None
}
});
if let Some((sig, mi)) = invoke {
let ret_type = strip_system(&reader.type_name_ctx(&sig.ret_type, &class_generic_names, &[]));
let param_names = method_param_names(reader, (mi + 1) as u32, &sig, false);
let params: Vec<String> = sig.param_types.iter().enumerate().map(|(i, t)| {
let pname = param_names.get(i).cloned().unwrap_or_else(|| format!("arg{i}"));
format!("{} {}", strip_system(&reader.type_name_ctx(t, &class_generic_names, &[])), pname)
}).collect();
s.push_str(&format!("{} delegate {} {}{}({});\n",
access, ret_type, name, generic_decl, params.join(", ")));
return Ok(s);
}
}
s.push_str(&format!("{} {}{}", keywords.join(" "), clean_display_class_name(&name), generic_decl));
let mut bases: Vec<String> = Vec::new();
if !is_interface && !is_struct && !is_enum
&& !base_full.is_empty() && base_simple != "Object" && base_simple != "object" {
if base_type_namespace(reader, extends).as_deref() == Some(ns.as_str()) {
bases.push(simple_name(&base_full));
} else {
bases.push(base_full.clone());
}
}
for ir in reader.tables.get(tbl::INTERFACEIMPL) {
if ir.col(0) == row_idx {
let iface = decode_coded(Coded::TypeDefOrRef, ir.col(1));
bases.push(simple_name(&strip_system(&reader.type_def_or_ref_name(iface))));
}
}
if !bases.is_empty() {
s.push_str(&format!(" : {}", bases.join(", ")));
}
s.push_str("\n{\n");
let field_range = reader.type_field_rows(row_idx);
let has_fields = !field_range.is_empty();
if is_enum {
let mut underlying = "int".to_string();
let mut members: Vec<String> = Vec::new();
for fi in field_range {
let f = &reader.tables.get(tbl::FIELD)[fi];
let fname = reader.field_name(f);
if fname == "value__" {
if let Ok(t) = reader.field_type(f) {
underlying = reader.type_name(&t);
}
continue;
}
let value = reader
.constant_for_field(fi as u32 + 1)
.map(|(tc, blob)| format_constant(tc, blob))
.unwrap_or_else(|| "0".into());
members.push(format!("{fname} = {value}"));
}
let header_marker = format!("enum {name}");
if let Some(pos) = s.rfind(&header_marker) {
s.replace_range(pos..pos + header_marker.len(), &format!("enum {name} : {underlying}"));
}
s.push_str(&format!(" {}\n", members.join(",\n ")));
s.push_str("}\n");
return Ok(s);
}
let events = reader.events_for_type(row_idx);
let event_names: std::collections::HashSet<String> = events.iter().map(|(n, _, _, _)| n.clone()).collect();
for fi in field_range {
let f = &reader.tables.get(tbl::FIELD)[fi];
let fname = reader.field_name(f);
if fname.starts_with("<") && fname.ends_with(">k__BackingField") {
continue;
}
if event_names.contains(&fname) {
continue;
}
let fflags = reader.field_flags(f);
let ftype = reader.field_type(f).map(|t| strip_system(&reader.type_name_ctx(&t, &class_generic_names, &[]))).unwrap_or_else(|_| "object".into());
let field_attrs = reader.custom_attributes_with_args_for(tbl::FIELD, fi as u32 + 1);
for (name, args) in &field_attrs {
s.push_str(&format!(" {}\n", format_attr_line(name, args)));
}
if fflags & 0x0040 != 0 {
let value = reader
.constant_for_field(fi as u32 + 1)
.map(|(tc, blob)| format_constant(tc, blob))
.unwrap_or_else(|| "default".into());
s.push_str(&format!(" {} const {} {} = {};\n", field_access(fflags), ftype, fname, value));
} else {
let fmod = if fflags & 0x0010 != 0 { "static " } else { "" };
s.push_str(&format!(" {} {}{} {};\n", field_access(fflags), fmod, ftype, fname));
}
}
if has_fields {
s.push('\n');
}
let properties = reader.properties_for_type(row_idx);
let mut property_methods: std::collections::HashSet<usize> = std::collections::HashSet::new();
for (pname, ptype, getter, setter) in &properties {
if let Some(g) = getter { property_methods.insert(*g); }
if let Some(s) = setter { property_methods.insert(*s); }
let access_str = if let Some(g) = getter {
let m = &reader.tables.get(tbl::METHODDEF)[*g];
method_access(reader.method_flags(m))
} else {
"public"
};
let type_str = strip_system(&reader.type_name_ctx(ptype, &class_generic_names, &[]));
let mut accessors: Vec<&str> = Vec::new();
if getter.is_some() { accessors.push("get"); }
if setter.is_some() { accessors.push("set"); }
s.push_str(&format!(" {} {} {} {{ {} }}\n", access_str, type_str, pname, accessors.join("; ") + ";"));
let _ = pname;
}
if !properties.is_empty() {
s.push('\n');
}
let mut event_methods: std::collections::HashSet<usize> = std::collections::HashSet::new();
for (ename, evt_type, add, remove) in &events {
if let Some(a) = add { event_methods.insert(*a); }
if let Some(r) = remove { event_methods.insert(*r); }
let access_str = if let Some(a) = add {
let m = &reader.tables.get(tbl::METHODDEF)[*a];
method_access(reader.method_flags(m))
} else {
"public"
};
s.push_str(&format!(" {} event {} {};\n", access_str, simple_name(&strip_system(evt_type)), ename));
}
if !events.is_empty() {
s.push('\n');
}
let explicit_impls = reader.explicit_impls_for_type(row_idx);
let explicit_map: std::collections::HashMap<usize, (String, String)> =
explicit_impls.iter().map(|(r, i, m)| (*r, (i.clone(), m.clone()))).collect();
let method_range = reader.type_method_rows(row_idx);
for mi in method_range {
if property_methods.contains(&mi) || event_methods.contains(&mi) {
continue;
}
let m = &reader.tables.get(tbl::METHODDEF)[mi];
let explicit = explicit_map.get(&mi).map(|(i, m)| (i.as_str(), m.as_str()));
let src = decompile_method(reader, m, (mi + 1) as u32, &name, explicit, &class_generic_names)?;
s.push_str(&src);
s.push('\n');
}
let nested_children = nested_types_for(reader, row_idx);
for child_idx in nested_children {
let child_src = decompile_nested_type(reader, child_idx)?;
s.push_str(&child_src);
s.push('\n');
}
s.push_str("}\n");
Ok(s)
}
fn nested_types_for(reader: &Reader<'_>, row_idx: u32) -> Vec<u32> {
let mut out = Vec::new();
let type_defs = reader.tables.get(tbl::TYPEDEF);
for (i, _row) in type_defs.iter().enumerate() {
let child_idx = (i + 1) as u32;
if reader.nested_parent(child_idx) == Some(row_idx) {
out.push(child_idx);
}
}
out
}
fn decompile_nested_type(reader: &Reader<'_>, row_idx: u32) -> Result<String> {
let src = decompile_type(reader, row_idx)?;
let mut lines = src.lines();
let mut body = String::new();
let mut started = false;
for line in &mut lines {
if !started && (line.starts_with("using ") || line.starts_with("namespace ") || line.is_empty()) {
continue;
}
started = true;
if line.is_empty() {
body.push('\n');
} else {
body.push_str(" ");
body.push_str(line);
body.push('\n');
}
}
Ok(body)
}
fn base_type_name(reader: &Reader<'_>, extends: CodedIndex) -> Option<String> {
extends.table?;
let n = reader.type_def_or_ref_name(extends);
Some(strip_system(&n))
}
fn base_type_namespace(reader: &Reader<'_>, extends: CodedIndex) -> Option<String> {
match extends.table {
Some(tbl::TYPEDEF) => {
let row = reader.tables.get(tbl::TYPEDEF).get(extends.row as usize - 1)?;
Some(reader.type_def_namespace(row))
}
Some(tbl::TYPEREF) => {
let row = reader.tables.get(tbl::TYPEREF).get(extends.row as usize - 1)?;
Some(reader.type_ref_namespace(row))
}
_ => None,
}
}
fn strip_system(n: &str) -> String {
if let Some(rest) = n.strip_prefix("System.") {
rest.to_string()
} else {
n.to_string()
}
}
pub fn strip_system_pub(n: &str) -> String {
strip_system(n)
}
fn simple_name(n: &str) -> String {
n.rsplit('.').next().unwrap_or(n).to_string()
}
fn decompile_method(reader: &Reader<'_>, m: &crate::metadata::tables::Row, method_row: u32, type_name: &str, explicit: Option<(&str, &str)>, class_params: &[String]) -> Result<String> {
let flags = reader.method_flags(m);
let name = reader.method_name(m);
let sig = reader.method_sig(m)?;
let is_static = flags & 0x0010 != 0;
let is_abstract = flags & 0x0400 != 0;
let is_virtual = flags & 0x0040 != 0;
let is_newslot = flags & 0x0100 != 0;
let is_final = flags & 0x0020 != 0;
let is_ctor = name == ".ctor" || name == ".cctor";
let is_explicit = explicit.is_some();
let is_pinvoke = flags & 0x2000 != 0;
let pinvoke = if is_pinvoke { reader.pinvoke_info(method_row) } else { None };
let generics = reader.generic_params_for(CodedIndex { table: Some(tbl::METHODDEF), row: method_row });
let method_generic_names: Vec<String> = generics.iter().map(|(_, n)| n.clone()).collect();
let generic_decl = if method_generic_names.is_empty() {
String::new()
} else {
format!("<{}>", method_generic_names.join(", "))
};
let mut mods = Vec::new();
if !is_explicit {
if !(is_ctor && is_static) {
let acc = method_access(flags);
if !acc.is_empty() {
mods.push(acc.to_string());
}
}
if is_static {
mods.push("static".into());
}
if is_abstract {
mods.push("abstract".into());
} else if is_virtual && is_newslot {
mods.push("virtual".into());
} else if is_virtual && is_final {
mods.push("override".into());
} else if is_virtual {
mods.push("override".into());
}
}
if is_pinvoke {
mods.push("extern".into());
}
let param_names = method_param_names(reader, method_row, &sig, is_static);
let param_rows = reader.method_param_rows(method_row);
let param_table = reader.tables.get(tbl::PARAM);
let mut param_defaults: std::collections::HashMap<u16, u32> = std::collections::HashMap::new();
let mut param_is_out: std::collections::HashSet<u16> = std::collections::HashSet::new();
let mut param_is_params: std::collections::HashSet<u16> = std::collections::HashSet::new();
for (idx, r) in param_table[param_rows.clone()].iter().enumerate() {
let flags = reader.param_flags(r);
let seq = reader.param_sequence(r);
let row_1based = (param_rows.start + idx) as u32 + 1;
if flags & 0x1000 != 0 {
param_defaults.insert(seq, row_1based);
}
if flags & 0x0002 != 0 {
param_is_out.insert(seq);
}
let attrs = reader.custom_attributes_with_args_for(tbl::PARAM, row_1based);
if attrs.iter().any(|(n, _)| n.contains("ParamArray")) {
param_is_params.insert(seq);
}
}
let params: Vec<String> = sig
.param_types
.iter()
.enumerate()
.map(|(i, t)| {
let pname = param_names.get(i).cloned().unwrap_or_else(|| format!("arg{i}"));
let seq = (i + 1) as u16;
if param_is_params.contains(&seq) {
return format!("params {} {}", strip_system(&reader.type_name_ctx(t, class_params, &method_generic_names)), pname);
}
if let Some(¶m_row) = param_defaults.get(&seq)
&& let Some((tc, blob)) = reader.constant_for_param(param_row) {
let def = format_constant(tc, blob);
return format!("{} {} = {}", strip_system(&reader.type_name_ctx(t, class_params, &method_generic_names)), pname, def);
}
if param_is_out.contains(&seq)
&& let Type::ByRef(inner) = t {
return format!("out {} {}", strip_system(&reader.type_name_ctx(inner, class_params, &method_generic_names)), pname);
}
format!("{} {}", strip_system(&reader.type_name_ctx(t, class_params, &method_generic_names)), pname)
})
.collect();
let display_name = if let Some((iface, mname)) = explicit {
format!("{}.{}", simple_name(&strip_system(iface)), mname)
} else {
clean_display_class_name(&name)
};
let mut header = if is_ctor {
format!(" {} {}{}({})",
mods.join(" "),
clean_display_class_name(type_name),
generic_decl,
params.join(", "),
)
} else {
let ret_type = strip_system(&reader.type_name_ctx(&sig.ret_type, class_params, &method_generic_names));
format!(" {} {} {}{}({})",
mods.join(" "),
ret_type,
display_name,
generic_decl,
params.join(", "),
)
};
let rva = reader.method_rva(m);
let body = reader.method_body(rva)?;
let method_attrs = reader.custom_attributes_with_args_for(tbl::METHODDEF, method_row);
let attr_prefix: String = method_attrs.iter()
.map(|(n, a)| format!(" {}\n", format_attr_line(n, a)))
.collect();
if is_pinvoke {
let dll = pinvoke.as_ref().map(|(d, _)| d.as_str()).unwrap_or("unknown");
let import_name = pinvoke.as_ref().map(|(_, n)| n.as_str()).unwrap_or(&name);
let entry = if import_name != name {
format!(", EntryPoint = \"{import_name}\"")
} else {
String::new()
};
return Ok(format!("{attr_prefix} [DllImport(\"{dll}\"{entry})]\n{header};\n"));
}
if is_abstract || body.is_none() {
return Ok(format!("{attr_prefix}{header};\n"));
}
let body = body.unwrap();
let local_types = reader.local_types(body.local_token);
let local_type_strs: Vec<String> = local_types
.iter()
.map(|t| strip_system(&reader.type_name_ctx(t, class_params, &[])))
.collect();
let body_src = decompile_body(reader, &body.code, ¶m_names, &local_type_strs, &sig, is_static, &body.exceptions)?;
let mut body_lines: Vec<String> = body_src.lines().map(|l| l.to_string()).collect();
restructure_lambdas(reader, method_row, &mut body_lines);
if is_ctor
&& let Some(idx) = body_lines.iter().position(|l| {
let t = l.trim();
t.starts_with("base(") && t.ends_with(';') && !t.starts_with("//")
}) {
let base_call = body_lines[idx].trim().trim_end_matches(';').to_string();
body_lines[idx] = String::new();
header.push_str(&format!(" : {base_call}"));
}
let body_src = body_lines.join("\n");
let mut s = String::new();
s.push_str(&attr_prefix);
s.push_str(&header);
s.push_str("\n {\n");
s.push_str(&body_src);
s.push_str(" }\n");
Ok(s)
}
fn method_param_names(
reader: &Reader<'_>,
method_row: u32,
sig: &MethodSig,
is_static: bool,
) -> Vec<String> {
let rows = reader.method_param_rows(method_row);
let params = reader.tables.get(tbl::PARAM);
let mut names: Vec<String> = Vec::with_capacity(sig.param_types.len());
for i in 0..sig.param_types.len() {
let seq = (i + 1) as u16;
let mut found = format!("arg{i}");
for r in params[rows.clone()].iter() {
if reader.param_sequence(r) == seq {
let n = reader.param_name(r);
if !n.is_empty() {
found = n;
}
break;
}
}
names.push(found);
}
let _ = is_static;
names
}
fn decompile_body(
reader: &Reader<'_>,
code: &[u8],
param_names: &[String],
local_type_strs: &[String],
sig: &MethodSig,
is_static: bool,
exceptions: &[crate::metadata::reader::ExceptionHandler],
) -> Result<String> {
let instrs = decode(code)?;
let targets = collect_targets(&instrs);
let mut stack: Vec<String> = Vec::new();
let mut out: Vec<String> = Vec::new();
let local_names: Vec<String> = (0..local_type_strs.len()).map(|i| format!("V_{i}")).collect();
let mut offset_to_line: std::collections::HashMap<usize, usize> = std::collections::HashMap::new();
for ins in &instrs {
if targets.contains(&ins.offset) {
offset_to_line.insert(ins.offset, out.len());
out.push(format!(" Label_{:04X}:", ins.offset));
}
offset_to_line.entry(ins.offset).or_insert_with(|| out.len());
if !handle_instr(reader, ins, &mut stack, &mut out, param_names, &local_names, sig, is_static)? {
out.push(format!(" // unsupported: {} ({})", ins.name, ins.offset));
stack.clear();
}
}
if !exceptions.is_empty() {
insert_exception_markers(reader, &mut out, &offset_to_line, exceptions);
}
restructure_if_else(&mut out);
restructure_do_while_loops(&mut out);
restructure_while_loops(&mut out);
restructure_for_loops(&mut out);
restructure_locks(&mut out);
restructure_using(&mut out);
restructure_foreach(&mut out);
restructure_collection_initializers(&mut out);
restructure_object_initializers(&mut out);
restructure_concat_arrays(&mut out);
restructure_switch(&mut out);
drop_redundant_default_stores(&mut out);
let mut s = String::new();
let foreach_vars: Vec<String> = out
.iter()
.filter_map(|l| {
let t = l.trim();
if let Some(rest) = t.strip_prefix("foreach (var ")
&& let Some(name) = rest.split(' ').next() {
return Some(name.to_string());
}
None
})
.collect();
for (i, lt) in local_type_strs.iter().enumerate() {
let lname = local_names.get(i).cloned().unwrap_or_else(|| format!("V_{i}"));
if !name_referenced(&out, &lname) {
continue;
}
if foreach_vars.contains(&lname) {
continue;
}
s.push_str(&format!(" {lt} {lname} = default;\n"));
}
if !local_type_strs.is_empty() {
s.push('\n');
}
for line in &out {
if line.is_empty() {
continue;
}
s.push_str(line);
s.push('\n');
}
Ok(s)
}
fn restructure_locks(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = &out[i];
let trimmed = line.trim();
if !trimmed.contains("Monitor.Enter(") {
i += 1;
continue;
}
let enter_args = match trimmed.split("Monitor.Enter(").nth(1) {
Some(s) => s.trim_end_matches(')'),
None => { i += 1; continue; }
};
let parts: Vec<&str> = enter_args.split(", ").collect();
if parts.len() < 2 {
i += 1; continue;
}
let lock_var = parts[0].trim();
if i == 0 || out[i - 1].trim() != "try {" {
i += 1;
continue;
}
let try_close = match out[i+1..].iter().position(|l| l.trim() == "}") {
Some(p) => i + 1 + p,
None => { i += 1; continue; }
};
if try_close + 1 >= out.len() || out[try_close + 1].trim() != "finally {" {
i += 1;
continue;
}
let finally_close = match out[try_close+2..].iter().position(|l| l.trim() == "}") {
Some(p) => try_close + 2 + p,
None => { i += 1; continue; }
};
let exit_line = out[try_close+2..finally_close].iter()
.find(|l| l.trim().contains("Monitor.Exit("));
let exit_line = match exit_line {
Some(l) => l.trim().to_string(),
None => { i += 1; continue; }
};
if !exit_line.contains(&format!("Monitor.Exit({lock_var})")) {
i += 1;
continue;
}
let try_idx = i - 1;
let lock_init_idx = (0..try_idx).rev()
.find(|&j| out[j].trim().starts_with(&format!("{lock_var} = ")));
let lock_expr = match lock_init_idx {
Some(idx) => {
let init = out[idx].trim().to_string();
let expr = init.trim_start_matches(&format!("{lock_var} = ")).trim_end_matches(';');
expr.to_string()
}
None => lock_var.to_string(),
};
let flag_init_idx = (0..try_idx).rev()
.find(|&j| {
let t = out[j].trim();
t.starts_with("V_") && t.ends_with("= 0;") && t.contains(" = ")
});
let body_start = i + 1;
let body_end = try_close;
out[try_idx] = format!(" lock ({lock_expr}) {{");
out[i] = String::new();
if let Some(idx) = lock_init_idx {
out[idx] = String::new();
}
if let Some(idx) = flag_init_idx {
if Some(idx) != lock_init_idx {
out[idx] = String::new();
}
}
for j in (body_start..body_end).rev() {
if !out[j].trim().is_empty() {
if out[j].trim().starts_with("goto ") && out[j].contains("leave try") {
out[j] = String::new();
}
break;
}
}
super::flow::indent_range(&mut out[..], body_start, body_end);
for line in out[try_close + 1..=finally_close].iter_mut() {
*line = String::new();
}
if finally_close + 1 < out.len() {
let next = out[finally_close + 1].trim();
if next.starts_with("Label_") && next.ends_with(':') {
out[finally_close + 1] = String::new();
}
}
i = finally_close + 2;
}
}
fn restructure_using(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = &out[i];
if line.trim() != "try {" {
i += 1;
continue;
}
if i == 0 {
i += 1;
continue;
}
let init_idx = (0..i).rev().find(|&j| !out[j].trim().is_empty());
let init_idx = match init_idx {
Some(idx) => idx,
None => { i += 1; continue; }
};
let init_line = out[init_idx].trim().to_string();
if !init_line.contains(" = ") || !init_line.ends_with(';') {
i += 1;
continue;
}
let eq_pos = match init_line.find(" = ") {
Some(p) => p,
None => { i += 1; continue; }
};
let resource_var = &init_line[..eq_pos];
let resource_expr = &init_line[eq_pos + 3..].trim_end_matches(';');
let try_close = match out[i+1..].iter().position(|l| l.trim() == "}") {
Some(p) => i + 1 + p,
None => { i += 1; continue; }
};
if try_close + 1 >= out.len() || out[try_close + 1].trim() != "finally {" {
i += 1;
continue;
}
let finally_close = match out[try_close+2..].iter().position(|l| l.trim() == "}") {
Some(p) => try_close + 2 + p,
None => { i += 1; continue; }
};
let finally_lines: Vec<&String> = out[try_close+2..finally_close].iter().collect();
let has_null_check = finally_lines.iter().any(|l| {
let t = l.trim();
(t.starts_with("if (!") || t.contains(" == null"))
&& t.contains("goto ")
&& t.contains(resource_var)
});
let has_dispose = finally_lines.iter().any(|l| {
l.trim().contains(&format!("{resource_var}.Dispose()"))
});
if !has_null_check || !has_dispose {
i += 1;
continue;
}
let body_start = i + 1;
let body_end = try_close;
out[i] = format!(" using ({resource_var} = {resource_expr}) {{");
out[init_idx] = String::new();
for j in (body_start..body_end).rev() {
if !out[j].trim().is_empty() {
if out[j].trim().starts_with("goto ") && out[j].contains("leave try") {
out[j] = String::new();
}
break;
}
}
super::flow::indent_range(&mut out[..], body_start, body_end);
for line in out[try_close + 1..=finally_close].iter_mut() {
*line = String::new();
}
if finally_close + 1 < out.len() {
let next = out[finally_close + 1].trim();
if next.starts_with("Label_") && next.ends_with(':') {
out[finally_close + 1] = String::new();
}
}
i = finally_close + 2;
}
}
fn restructure_foreach(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = &out[i];
let trimmed = line.trim();
if !trimmed.ends_with(".GetEnumerator();") {
i += 1;
continue;
}
let eq_pos = match trimmed.find(" = ") {
Some(p) => p,
None => { i += 1; continue; }
};
let enum_var = &trimmed[..eq_pos];
let collection = trimmed[eq_pos + 3..].trim_end_matches(".GetEnumerator();");
let try_idx = (i+1..out.len()).find(|&j| !out[j].trim().is_empty());
let try_idx = match try_idx {
Some(idx) if out[idx].trim() == "try {" => idx,
_ => { i += 1; continue; }
};
let while_idx = (try_idx+1..out.len()).find(|&j| {
let t = out[j].trim();
t.starts_with("while (") && t.contains(&format!("{enum_var}.MoveNext()")) && t.ends_with("{")
});
let while_idx = match while_idx {
Some(idx) => idx,
None => { i += 1; continue; }
};
let current_idx = (while_idx+1..out.len()).find(|&j| !out[j].trim().is_empty());
let (current_idx, item_var) = match current_idx {
Some(idx) => {
let t = out[idx].trim();
if t.contains(&format!("{enum_var}.get_Current()")) && t.contains(" = ") {
let eq = t.find(" = ").unwrap();
let item = t[..eq].to_string();
(idx, item)
} else {
{ i += 1; continue; }
}
}
None => { i += 1; continue; }
};
let while_close = match out[while_idx+1..].iter().position(|l| l.trim() == "}") {
Some(p) => while_idx + 1 + p,
None => { i += 1; continue; }
};
let try_close = match out[while_close+1..].iter().position(|l| l.trim() == "}") {
Some(p) => while_close + 1 + p,
None => { i += 1; continue; }
};
if try_close + 1 >= out.len() || out[try_close + 1].trim() != "finally {" {
i += 1;
continue;
}
let finally_close = match out[try_close+2..].iter().position(|l| l.trim() == "}") {
Some(p) => try_close + 2 + p,
None => { i += 1; continue; }
};
let has_dispose = out[try_close+2..finally_close].iter()
.any(|l| l.trim().contains(&format!("{enum_var}.Dispose()")));
if !has_dispose {
i += 1;
continue;
}
out[i] = format!(" foreach (var {item_var} in {collection}) {{");
out[try_idx] = String::new();
out[while_idx] = String::new();
out[current_idx] = String::new();
out[while_close] = String::new();
for line in out[current_idx + 1..while_close].iter_mut() {
if !line.trim().is_empty() {
*line = format!(" {}", line.trim_start());
}
}
for line in out[while_close + 1..try_close].iter_mut() {
let t = line.trim();
if !t.is_empty() && t.starts_with("goto ") {
*line = String::new();
}
}
for line in out[try_close + 1..=finally_close].iter_mut() {
*line = String::new();
}
if finally_close + 1 < out.len() {
let next = out[finally_close + 1].trim();
if next.starts_with("Label_") && next.ends_with(':') {
out[finally_close + 1] = String::new();
}
}
i = finally_close + 2;
}
}
fn restructure_collection_initializers(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = out[i].clone();
let trimmed = line.trim();
let indent = &line[..line.len() - trimmed.len()];
let var_prefix = if trimmed.starts_with("var ") { "var " } else { "" };
let t_body = trimmed.strip_prefix("var ").unwrap_or(trimmed);
if !t_body.starts_with("V_tmp_") || !t_body.contains(" = new ") || !t_body.ends_with("();") {
i += 1;
continue;
}
let eq_pos = t_body.find(" = ").unwrap();
let temp_var = &t_body[..eq_pos];
let ctor_expr = &t_body[eq_pos + 3..].trim_end_matches(';');
let mut add_args: Vec<String> = Vec::new();
let mut j = i + 1;
while j < out.len() {
let t = out[j].trim();
if t == format!("{temp_var}.Add();") {
break;
}
let prefix = format!("{temp_var}.Add(");
if t.starts_with(&prefix) && t.ends_with(");") {
let arg = &t[prefix.len()..].trim_end_matches(");");
add_args.push(arg.to_string());
j += 1;
} else if t.is_empty() {
j += 1;
} else {
break;
}
}
if add_args.is_empty() {
i += 1;
continue;
}
let initializer = format!("{ctor_expr} {{ {} }}", add_args.join(", "));
out[i] = format!("{indent}{var_prefix}{temp_var} = {initializer};");
let add_line = format!("{temp_var}.Add(");
for line in out[i + 1..j].iter_mut() {
if line.trim().starts_with(&add_line) {
*line = String::new();
}
}
i = j;
}
}
fn restructure_object_initializers(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = out[i].clone();
let trimmed = line.trim();
let indent = &line[..line.len() - trimmed.len()];
let var_prefix = if trimmed.starts_with("var ") { "var " } else { "" };
let t_body = trimmed.strip_prefix("var ").unwrap_or(trimmed);
let (temp_var, ctor_expr) = if (t_body.starts_with("V_") || t_body.starts_with("V_tmp_"))
&& t_body.contains(" = new ")
&& t_body.ends_with(");")
{
let eq = t_body.find(" = ").unwrap();
(t_body[..eq].to_string(), t_body[eq + 3..].trim_end_matches(';').to_string())
} else if t_body.starts_with("V_") && t_body.contains(" = default(") && t_body.ends_with(");") {
let eq = t_body.find(" = ").unwrap();
let inner = t_body[eq + 3 + "default(".len()..].trim_end_matches(");");
(t_body[..eq].to_string(), format!("new {inner}"))
} else {
i += 1;
continue;
};
let mut members: Vec<(String, String)> = Vec::new();
let mut j = i + 1;
while j < out.len() {
let t = out[j].trim();
let prefix = format!("{temp_var}.");
if t.starts_with(&prefix) && t.ends_with(';') {
let rest = &t[prefix.len()..];
if let Some(eq_pos) = rest.find(" = ") {
let member = &rest[..eq_pos];
if member.contains('.') {
break;
}
let value = rest[eq_pos + 3..].trim_end_matches(';');
members.push((member.to_string(), value.to_string()));
j += 1;
} else {
break;
}
} else if t.is_empty() {
j += 1;
} else {
break;
}
}
if members.is_empty() {
i += 1;
continue;
}
let init = members
.iter()
.map(|(m, v)| format!("{m} = {v}"))
.collect::<Vec<_>>()
.join(", ");
let base = ctor_expr.strip_suffix("()").unwrap_or(&ctor_expr);
out[i] = format!("{indent}{var_prefix}{temp_var} = {base} {{ {init} }};");
for line in out[i + 1..j].iter_mut() {
*line = String::new();
}
i = j;
}
}
fn restructure_concat_arrays(out: &mut [String]) {
let mut i = 0;
while i < out.len() {
let line = out[i].clone();
let trimmed = line.trim();
let concat_pos = match trimmed.find("Concat(") {
Some(p) => p,
None => {
i += 1;
continue;
}
};
let open = concat_pos + "Concat(".len();
let close = match trimmed[open..].find(')') {
Some(p) => open + p,
None => {
i += 1;
continue;
}
};
let arg = trimmed[open..close].trim();
if !arg.starts_with("V_tmp_") || arg.contains('.') || arg.contains('[') {
i += 1;
continue;
}
let temp = arg.to_string();
let mut decl_idx = None;
let mut elem_lines: Vec<(usize, String)> = Vec::new();
let mut k = i;
while k > 0 {
k -= 1;
let t = out[k].trim();
let elem_prefix = format!("{temp}[");
if t.starts_with(&elem_prefix) && t.ends_with(';') {
elem_lines.push((k, t.to_string()));
continue;
}
let decl_prefix = format!("var {temp} = new string[");
let bare_prefix = format!("{temp} = new string[");
if t.starts_with(&decl_prefix) || t.starts_with(&bare_prefix) {
decl_idx = Some(k);
}
break;
}
let decl_idx = match decl_idx {
Some(d) => d,
None => {
i += 1;
continue;
}
};
let size: usize = match out[decl_idx]
.trim()
.rsplit('[')
.next()
.and_then(|s| s.strip_suffix("];"))
.and_then(|s| s.trim().parse().ok())
{
Some(n) => n,
None => {
i += 1;
continue;
}
};
if elem_lines.len() != size {
i += 1;
continue;
}
let mut elems: Vec<Option<String>> = vec![None; size];
let mut ok = true;
for (_, t) in &elem_lines {
let rest = &t[temp.len() + 1..]; let close_br = match rest.find(']') {
Some(p) => p,
None => {
ok = false;
break;
}
};
let idx: usize = match rest[..close_br].parse() {
Ok(n) => n,
Err(_) => {
ok = false;
break;
}
};
let val = match rest[close_br + 1..].strip_prefix(" = ") {
Some(v) => v.trim_end_matches(';'),
None => {
ok = false;
break;
}
};
if idx >= size || elems[idx].is_some() {
ok = false;
break;
}
let is_literal = (val.starts_with('"') && val.ends_with('"'))
|| val == "null"
|| val.parse::<f64>().is_ok();
let needs_parens = !is_literal && val.contains(['?', '&', '|', '^', '<', '>', '=']);
elems[idx] = Some(if needs_parens {
format!("({val})")
} else {
val.to_string()
});
}
if !ok || elems.iter().any(|e| e.is_none()) {
i += 1;
continue;
}
let used_elsewhere = out.iter().enumerate().any(|(k2, l)| {
k2 != decl_idx
&& !elem_lines.iter().any(|(k3, _)| *k3 == k2)
&& k2 != i
&& l.split(|c: char| !(c.is_alphanumeric() || c == '_'))
.any(|tok| tok == temp)
});
if used_elsewhere {
i += 1;
continue;
}
let indent = &line[..line.len() - trimmed.len()];
let owner_start = trimmed[..concat_pos]
.rfind('.')
.map(|dot| {
let before = &trimmed[..dot];
before
.rfind(|c: char| !(c.is_alphanumeric() || c == '_'))
.map(|q| q + 1)
.unwrap_or(0)
})
.unwrap_or(concat_pos);
let joined = elems
.into_iter()
.map(|e| e.unwrap())
.collect::<Vec<_>>()
.join(" + ");
out[i] = format!(
"{indent}{}{}{}",
&trimmed[..owner_start],
joined,
&trimmed[close + 1..]
);
out[decl_idx] = String::new();
for (k4, _) in elem_lines {
out[k4] = String::new();
}
i += 1;
}
}
fn restructure_lambdas(reader: &Reader<'_>, method_row: u32, out: &mut [String]) {
let mut captures: std::collections::HashMap<String, std::collections::HashMap<String, String>> =
std::collections::HashMap::new();
for line in out.iter() {
let t = line.trim();
let t = t.strip_prefix("var ").unwrap_or(t);
if t.starts_with("V_") && t.contains(" = new DisplayClass { ") && t.ends_with(" };") {
let eq = t.find(" = ").unwrap();
let temp = t[..eq].to_string();
let members = t[eq + 3 + "new DisplayClass ".len() + 2..].trim_end_matches(" };");
let mut map = std::collections::HashMap::new();
for part in members.split(", ") {
if let Some(fe) = part.find(" = ") {
map.insert(part[..fe].to_string(), part[fe + 3..].to_string());
}
}
captures.insert(temp, map);
}
}
if captures.is_empty() {
return;
}
let owner = owner_type_row(reader, method_row);
let mut i = 0;
while i < out.len() {
let line = out[i].clone();
let trimmed = line.trim();
let indent = &line[..line.len() - trimmed.len()];
let Some(func_pos) = trimmed.find("new Func<") else { i += 1; continue };
let Some(open_rel) = trimmed[func_pos..].find('(') else { i += 1; continue };
let open = func_pos + open_rel;
let Some(close) = matching_paren(trimmed, open) else { i += 1; continue };
let ctor_args = &trimmed[open + 1..close];
let mut parts = ctor_args.split(',');
let (Some(ctx_raw), Some(lambda_raw)) = (parts.next(), parts.next()) else { i += 1; continue };
if parts.next().is_some() {
i += 1;
continue;
}
let ctx = ctx_raw.trim();
let lambda_ref = lambda_raw.trim();
let Some(cap) = captures.get(ctx) else { i += 1; continue };
let Some(lambda_name) = lambda_ref.strip_prefix("DisplayClass.") else { i += 1; continue };
let after = &trimmed[close + 1..];
let Some(inv_rel) = after.find(".Invoke(") else { i += 1; continue };
let inv_open = close + 1 + inv_rel + ".Invoke(".len() - 1;
let Some(inv_close) = matching_paren(trimmed, inv_open) else { i += 1; continue };
let invoke_args = &trimmed[inv_open + 1..inv_close];
let Some((sig, param_names, body_src)) = lambda_body(reader, owner, lambda_name) else { i += 1; continue };
let stmts: Vec<&str> = body_src.lines().map(|l| l.trim()).filter(|l| !l.is_empty()).collect();
if stmts.len() != 1 {
i += 1;
continue;
}
let Some(expr) = stmts[0].strip_prefix("return ").and_then(|e| e.strip_suffix(';')) else { i += 1; continue };
let mut expr = expr.to_string();
for (field, value) in cap {
expr = expr.replace(&format!("this.{field}"), value);
}
let params: Vec<String> = sig
.param_types
.iter()
.zip(¶m_names)
.map(|(t, n)| format!("{} {n}", strip_system(&reader.type_name(t))))
.collect();
let lambda = format!("({}) => {}", params.join(", "), expr);
let prefix = &trimmed[..func_pos];
let suffix = &trimmed[inv_close + 1..];
out[i] = format!("{indent}{prefix}({lambda})({invoke_args}){suffix}");
if let Some(init_idx) = out.iter().position(|l| l.contains(ctx) && l.contains(" = new DisplayClass { ")) {
let used_elsewhere = out
.iter()
.enumerate()
.any(|(k, l)| k != init_idx && l.contains(ctx));
if !used_elsewhere {
out[init_idx] = String::new();
}
}
i += 1;
}
}
fn matching_paren(s: &str, open: usize) -> Option<usize> {
let mut depth = 0usize;
for (k, ch) in s[open..].char_indices() {
match ch {
'(' => depth += 1,
')' => {
depth -= 1;
if depth == 0 {
return Some(open + k);
}
}
_ => {}
}
}
None
}
fn owner_type_row(reader: &Reader<'_>, method_row: u32) -> Option<u32> {
let type_defs = reader.tables.get(tbl::TYPEDEF);
for (i, td) in type_defs.iter().enumerate() {
let start = td.col(5);
let next = type_defs
.get(i + 1)
.map(|r| r.col(5))
.unwrap_or_else(|| reader.tables.row_count(tbl::METHODDEF) + 1);
if method_row >= start && method_row < next {
return Some((i + 1) as u32);
}
}
None
}
fn lambda_body(
reader: &Reader<'_>,
owner: Option<u32>,
lambda_name: &str,
) -> Option<(MethodSig, Vec<String>, String)> {
for child in nested_types_for(reader, owner?) {
let row = &reader.tables.get(tbl::TYPEDEF)[child as usize - 1];
if clean_display_class_name(&reader.type_def_name(row)) != "DisplayClass" {
continue;
}
for mi in reader.type_method_rows(child) {
let m = &reader.tables.get(tbl::METHODDEF)[mi];
if clean_display_class_name(&reader.method_name(m)) != lambda_name {
continue;
}
let method_row = (mi + 1) as u32;
let sig = reader.method_sig(m).ok()?;
let param_names = method_param_names(reader, method_row, &sig, false);
let rva = reader.method_rva(m);
let body = reader.method_body(rva).ok()??;
let local_strs: Vec<String> = reader
.local_types(body.local_token)
.iter()
.map(|t| strip_system(&reader.type_name(t)))
.collect();
let src = decompile_body(reader, &body.code, ¶m_names, &local_strs, &sig, false, &body.exceptions).ok()?;
return Some((sig, param_names, src));
}
}
None
}
fn drop_redundant_default_stores(out: &mut [String]) {
const DEFAULTS: [&str; 9] = ["0", "false", "null", "0.0", "0f", "0.0f", "0L", "0UL", "0u"];
for line in out.iter_mut() {
let t = line.trim();
if t.is_empty() {
continue;
}
let body = t.strip_suffix(';');
let is_redundant = body
.is_some_and(|b| {
b.starts_with("V_")
&& !b.contains('(')
&& b.split_once(" = ")
.is_some_and(|(_, v)| DEFAULTS.contains(&v.trim()))
});
if is_redundant {
*line = String::new();
continue;
}
break;
}
}
fn clean_display_class_name(name: &str) -> String {
if name.contains("<>c__DisplayClass") {
return "DisplayClass".to_string();
}
if name.contains("b__")
&& let Some(pos) = name.find("b__") {
let suffix = &name[pos + 3..];
return format!("lambda_{suffix}");
}
if let Some(pos) = name.find('`') {
return name[..pos].to_string();
}
name.to_string()
}
pub fn clean_display_class_name_pub(name: &str) -> String {
clean_display_class_name(name)
}
fn clean_field_name(fname: &str) -> String {
if fname.starts_with('<')
&& let Some(end) = fname.find('>') {
return fname[1..end].to_string();
}
fname.to_string()
}
pub fn clean_field_name_pub(fname: &str) -> String {
clean_field_name(fname)
}
fn format_attr_line(name: &str, args: &str) -> String {
let simple = simple_name(&strip_system(name));
let short = simple.strip_suffix("Attribute").unwrap_or(&simple);
if args.is_empty() {
format!("[{short}]")
} else {
format!("[{short}({args})]")
}
}
fn insert_exception_markers(
reader: &Reader<'_>,
out: &mut Vec<String>,
offset_to_line: &std::collections::HashMap<usize, usize>,
exceptions: &[crate::metadata::reader::ExceptionHandler],
) {
let mut sorted = exceptions.to_vec();
sorted.sort_by_key(|e| (e.try_offset, e.handler_offset));
for eh in sorted.iter().rev() {
let try_start = *offset_to_line.get(&(eh.try_offset as usize)).unwrap_or(&0);
let handler_start = *offset_to_line.get(&(eh.handler_offset as usize)).unwrap_or(&0);
let _try_end = *offset_to_line.get(&((eh.try_offset + eh.try_length) as usize)).unwrap_or(&handler_start);
let handler_end = *offset_to_line.get(&((eh.handler_offset + eh.handler_length) as usize)).unwrap_or(&out.len());
let catch_header = match eh.flags {
0 => {
let type_name = token_type_name(reader, eh.class_token);
format!(" catch ({}) {{", simple_name(&strip_system(&type_name)))
}
2 => " finally {".to_string(),
3 => " fault {".to_string(),
1 => " catch (/* filter */) {".to_string(),
_ => " catch {".to_string(),
};
if handler_end <= out.len() {
out.insert(handler_end, " }".to_string());
}
if handler_start <= out.len() {
out.insert(handler_start, catch_header);
out.insert(handler_start, " }".to_string());
}
if try_start <= out.len() {
out.insert(try_start, " try {".to_string());
}
}
}
fn token_type_name(reader: &Reader<'_>, token: u32) -> String {
let table = (token >> 24) as u8;
let row = (token & 0x00FF_FFFF) as usize;
match table {
tbl::TYPEREF => {
if let Some(r) = reader.tables.get(tbl::TYPEREF).get(row - 1) {
let ns = reader.type_ref_namespace(r);
let name = reader.type_ref_name(r);
if ns.is_empty() { name } else { format!("{ns}.{name}") }
} else { "?".into() }
}
tbl::TYPEDEF => {
if let Some(r) = reader.tables.get(tbl::TYPEDEF).get(row - 1) {
let ns = reader.type_def_namespace(r);
let name = reader.type_def_name(r);
if ns.is_empty() { name } else { format!("{ns}.{name}") }
} else { "?".into() }
}
_ => "?".into(),
}
}
fn collect_targets(instrs: &[Instruction]) -> std::collections::HashSet<usize> {
let mut set = std::collections::HashSet::new();
for ins in instrs {
match &ins.operand {
Operand::BrTarget(o) => {
set.insert(target_offset(ins.offset, ins.size, *o));
}
Operand::ShortBrTarget(o) => {
set.insert(target_offset(ins.offset, ins.size, *o as i32));
}
Operand::Switch(ts) => {
let base = ins.offset + ins.size;
for t in ts {
set.insert(target_offset_from(base, *t));
}
}
_ => {}
}
}
set
}
fn target_offset(instr_offset: usize, instr_size: usize, rel: i32) -> usize {
let base = instr_offset as i64 + instr_size as i64;
(base + rel as i64).max(0) as usize
}
fn target_offset_from(base: usize, rel: i32) -> usize {
(base as i64 + rel as i64).max(0) as usize
}
fn arg_name(param_names: &[String], is_static: bool, idx: u32) -> String {
if !is_static && idx == 0 {
return "this".into();
}
let real = if is_static { idx } else { idx - 1 };
param_names
.get(real as usize)
.cloned()
.unwrap_or_else(|| format!("arg_{real}"))
}
#[allow(clippy::too_many_arguments)]
fn handle_instr(
reader: &Reader<'_>,
ins: &Instruction,
stack: &mut Vec<String>,
out: &mut Vec<String>,
param_names: &[String],
local_names: &[String],
sig: &MethodSig,
is_static: bool,
) -> Result<bool> {
let name = ins.name;
let push = |stack: &mut Vec<String>, v: String| stack.push(v);
let pop = |stack: &mut Vec<String>| stack.pop().unwrap_or_else(|| "/*?*/".into());
let stmt = |out: &mut Vec<String>, s: String| out.push(format!(" {s}"));
match name {
"nop" | "break" => {}
"ret" => {
if matches!(sig.ret_type, Type::Void) && stack.is_empty() {
stmt(out, "return;".into());
} else if !stack.is_empty() {
let v = pop(stack);
let v = if matches!(sig.ret_type, Type::Bool) { bool_literal(&v) } else { v };
stmt(out, format!("return {v};"));
} else {
stmt(out, "return;".into());
}
}
"ldnull" => push(stack, "null".into()),
"dup" => {
if let Some(top) = stack.last().cloned() {
if top.starts_with("new ") {
let temp = format!("V_tmp_{}", out.len());
stmt(out, format!("var {temp} = {top};"));
if let Some(t) = stack.last_mut() {
*t = temp.clone();
}
push(stack, temp);
} else {
push(stack, top);
}
}
}
"pop" => {
let _ = pop(stack);
}
"ldc.i4.m1" => push(stack, "-1".into()),
"ldc.i4.0" => push(stack, "0".into()),
"ldc.i4.1" => push(stack, "1".into()),
"ldc.i4.2" => push(stack, "2".into()),
"ldc.i4.3" => push(stack, "3".into()),
"ldc.i4.4" => push(stack, "4".into()),
"ldc.i4.5" => push(stack, "5".into()),
"ldc.i4.6" => push(stack, "6".into()),
"ldc.i4.7" => push(stack, "7".into()),
"ldc.i4.8" => push(stack, "8".into()),
"ldc.i4.s" => {
if let Operand::I8(v) = &ins.operand { push(stack, v.to_string()); }
}
"ldc.i4" => {
if let Operand::I32(v) = &ins.operand { push(stack, v.to_string()); }
}
"ldc.i8" => {
if let Operand::I64(v) = &ins.operand { push(stack, format!("{v}L")); }
}
"ldc.r4" => {
if let Operand::R4(v) = &ins.operand { push(stack, format!("{v}f")); }
}
"ldc.r8" => {
if let Operand::R8(v) = &ins.operand { push(stack, format!("{v}")); }
}
"ldarg.0" => push(stack, arg_name(param_names, is_static, 0)),
"ldarg.1" => push(stack, arg_name(param_names, is_static, 1)),
"ldarg.2" => push(stack, arg_name(param_names, is_static, 2)),
"ldarg.3" => push(stack, arg_name(param_names, is_static, 3)),
"ldarg.s" | "ldarg" => {
let idx = var_index(&ins.operand);
push(stack, arg_name(param_names, is_static, idx));
}
"ldarga.s" | "ldarga" => {
let idx = var_index(&ins.operand);
push(stack, arg_name(param_names, is_static, idx));
}
"starg.s" | "starg" => {
let idx = var_index(&ins.operand);
let v = pop(stack);
stmt(out, format!("{} = {v};", arg_name(param_names, is_static, idx)));
}
"ldloc.0" => push(stack, local_name(local_names, 0)),
"ldloc.1" => push(stack, local_name(local_names, 1)),
"ldloc.2" => push(stack, local_name(local_names, 2)),
"ldloc.3" => push(stack, local_name(local_names, 3)),
"ldloc.s" | "ldloc" => {
let idx = var_index(&ins.operand);
push(stack, local_name(local_names, idx as usize));
}
"ldloca.s" | "ldloca" => {
let idx = var_index(&ins.operand);
push(stack, local_name(local_names, idx as usize));
}
"stloc.0" => store_local(out, stack, local_names, 0),
"stloc.1" => store_local(out, stack, local_names, 1),
"stloc.2" => store_local(out, stack, local_names, 2),
"stloc.3" => store_local(out, stack, local_names, 3),
"stloc.s" | "stloc" => {
let idx = var_index(&ins.operand);
store_local(out, stack, local_names, idx as usize);
}
"add" => binop(stack, "+"),
"sub" => binop(stack, "-"),
"mul" => binop(stack, "*"),
"div" => binop(stack, "/"),
"div.un" => binop(stack, "/"),
"rem" => binop(stack, "%"),
"rem.un" => binop(stack, "%"),
"and" => binop(stack, "&"),
"or" => binop(stack, "|"),
"xor" => binop(stack, "^"),
"shl" => binop(stack, "<<"),
"shr" => binop(stack, ">>"),
"shr.un" => binop(stack, ">>"),
"add.ovf" => binop(stack, "+"),
"add.ovf.un" => binop(stack, "+"),
"sub.ovf" => binop(stack, "-"),
"sub.ovf.un" => binop(stack, "-"),
"mul.ovf" => binop(stack, "*"),
"mul.ovf.un" => binop(stack, "*"),
"neg" => unop(stack, "-"),
"not" => unop(stack, "~"),
"conv.i1" => conv(stack, "sbyte"),
"conv.i2" => conv(stack, "short"),
"conv.i4" => conv(stack, "int"),
"conv.i8" => conv(stack, "long"),
"conv.u1" => conv(stack, "byte"),
"conv.u2" => conv(stack, "ushort"),
"conv.u4" => conv(stack, "uint"),
"conv.u8" => conv(stack, "ulong"),
"conv.r4" => conv(stack, "float"),
"conv.r8" => conv(stack, "double"),
"conv.i" => conv(stack, "IntPtr"),
"conv.u" => conv(stack, "UIntPtr"),
"conv.r.un" => conv(stack, "double"),
"ldstr" => {
if let Operand::Token(tok) = &ins.operand {
let idx = tok & 0x00FF_FFFF;
let s = reader.root.get_user_string(idx).unwrap_or_default();
push(stack, quote_string(&s));
}
}
"call" | "callvirt" => {
if let Operand::Token(tok) = &ins.operand {
let (owner, mname, csig) = match resolve_method(reader, *tok) {
Some(v) => v,
None => return Ok(false),
};
let argc = csig.param_types.len();
let mut args: Vec<String> = Vec::with_capacity(argc);
for _ in 0..argc {
args.push(pop(stack));
}
args.reverse();
let rendered_args: Vec<String> = args
.iter()
.enumerate()
.map(|(i, a)| {
if matches!(csig.param_types.get(i), Some(Type::ByRef(_))) {
format!("{} {a}", byref_keyword(reader, *tok, i, a))
} else {
a.clone()
}
})
.collect();
let expr = if csig.has_this {
let obj = pop(stack);
if mname == ".ctor" {
if owner != "Object" && owner != "object" {
stmt(out, "base();".into());
}
String::new()
} else if let Some(prop) = property_name_for_accessor(reader, *tok) {
if mname.starts_with("set_") {
let val = rendered_args.first().cloned().unwrap_or_default();
format!("{obj}.{prop} = {val}")
} else {
format!("{obj}.{prop}")
}
} else {
format!("{obj}.{mname}({})", rendered_args.join(", "))
}
} else if (owner == "String" || owner == "string")
&& mname == "Concat"
&& !csig.param_types.is_empty()
&& csig.param_types.iter().all(|t| matches!(t, Type::String))
{
rendered_args.join(" + ")
} else {
format!("{owner}.{mname}({})", rendered_args.join(", "))
};
if expr.is_empty() {
} else if matches!(csig.ret_type, Type::Void) {
stmt(out, format!("{expr};"));
} else {
push(stack, expr);
}
} else {
return Ok(false);
}
}
"newobj" => {
if let Operand::Token(tok) = &ins.operand {
let expr = build_newobj(reader, *tok, stack);
push(stack, expr);
} else {
return Ok(false);
}
}
"ldfld" | "ldflda" => {
if let Operand::Token(tok) = &ins.operand {
let (tname, fname) = field_ref(reader, *tok);
let obj = pop(stack);
push(stack, format!("{obj}.{}", clean_field_name(&fname)));
let _ = tname;
}
}
"ldsfld" | "ldsflda" => {
if let Operand::Token(tok) = &ins.operand {
let (tname, fname) = field_ref(reader, *tok);
push(stack, format!("{tname}.{}", clean_field_name(&fname)));
}
}
"stfld" => {
if let Operand::Token(tok) = &ins.operand {
let (_, fname) = field_ref(reader, *tok);
let val = pop(stack);
let obj = pop(stack);
let val = if field_token_is_bool(reader, *tok) { bool_literal(&val) } else { val };
stmt(out, format!("{obj}.{} = {val};", clean_field_name(&fname)));
}
}
"stsfld" => {
if let Operand::Token(tok) = &ins.operand {
let (tname, fname) = field_ref(reader, *tok);
let val = pop(stack);
stmt(out, format!("{tname}.{fname} = {val};"));
}
}
"ldind.i4" | "ldind.i8" | "ldind.r4" | "ldind.r8"
| "ldind.i" | "ldind.u" | "ldind.ref"
| "ldind.i1" | "ldind.u1" | "ldind.i2" | "ldind.u2"
| "ldind.u4" => {
let addr = pop(stack);
push(stack, deref_or_plain(param_names, sig, &addr));
}
"stind.i4" | "stind.i8" | "stind.r4" | "stind.r8"
| "stind.i" | "stind.ref"
| "stind.i1" | "stind.i2" => {
let val = pop(stack);
let addr = pop(stack);
stmt(out, format!("{} = {val};", deref_or_plain(param_names, sig, &addr)));
}
"box" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let v = pop(stack);
if type_token_is_enum(reader, *tok) {
push(stack, format!("(({})({}))", t, v));
} else {
push(stack, format!("(object)({v})"));
}
}
}
"unbox.any" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let v = pop(stack);
push(stack, format!("({t})({v})"));
}
}
"castclass" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let v = pop(stack);
let v_s = strip_outer_parens(&v);
push(stack, format!("({t})({v_s})"));
}
}
"isinst" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let v = pop(stack);
let v_s = strip_outer_parens(&v);
if type_token_is_value(reader, *tok) {
push(stack, format!("{v_s} is {t}"));
} else {
push(stack, format!("{v_s} as {t}"));
}
}
}
"newarr" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let count = pop(stack);
push(stack, format!("new {t}[{count}]"));
}
}
"ldlen" => {
let v = pop(stack);
push(stack, format!("{v}.Length"));
}
"ldelem.i1" | "ldelem.u1" | "ldelem.i2" | "ldelem.u2" | "ldelem.i4" | "ldelem.u4"
| "ldelem.i8" | "ldelem.i" | "ldelem.r4" | "ldelem.r8" | "ldelem.ref" | "ldelem" => {
let idx = pop(stack);
let arr = pop(stack);
push(stack, format!("{arr}[{idx}]"));
}
"stelem.i" | "stelem.i1" | "stelem.i2" | "stelem.i4" | "stelem.i8"
| "stelem.r4" | "stelem.r8" | "stelem.ref" | "stelem" => {
let val = pop(stack);
let idx = pop(stack);
let arr = pop(stack);
stmt(out, format!("{arr}[{idx}] = {val};"));
}
"throw" => {
let v = pop(stack);
stmt(out, format!("throw {v};"));
}
"rethrow" => stmt(out, "throw;".into()),
"br" | "br.s" => {
let tgt = branch_target_of(ins);
stmt(out, format!("goto Label_{tgt:04X};"));
}
"leave" | "leave.s" => {
let tgt = branch_target_of(ins);
stmt(out, format!("goto Label_{tgt:04X}; // leave try"));
}
"brfalse" | "brfalse.s" => {
let tgt = branch_target_of(ins);
let v = pop(stack);
if looks_bool(&v) {
stmt(out, format!("if (!{v}) goto Label_{tgt:04X};"));
} else {
stmt(out, format!("if ({v} == null) goto Label_{tgt:04X};"));
}
}
"brtrue" | "brtrue.s" => {
let tgt = branch_target_of(ins);
let v = pop(stack);
if looks_bool(&v) {
stmt(out, format!("if ({v}) goto Label_{tgt:04X};"));
} else {
stmt(out, format!("if ({v} != null) goto Label_{tgt:04X};"));
}
}
"beq" | "beq.s" => cmp_branch(out, stack, ins, "=="),
"bge" | "bge.s" => cmp_branch(out, stack, ins, ">="),
"bgt" | "bgt.s" => cmp_branch(out, stack, ins, ">"),
"ble" | "ble.s" => cmp_branch(out, stack, ins, "<="),
"blt" | "blt.s" => cmp_branch(out, stack, ins, "<"),
"bne.un" | "bne.un.s" => cmp_branch(out, stack, ins, "!="),
"bge.un" | "bge.un.s" => cmp_branch(out, stack, ins, ">="),
"bgt.un" | "bgt.un.s" => cmp_branch(out, stack, ins, ">"),
"ble.un" | "ble.un.s" => cmp_branch(out, stack, ins, "<="),
"blt.un" | "blt.un.s" => cmp_branch(out, stack, ins, "<"),
"ceq" => cmp_op(stack, "=="),
"cgt" => cmp_op(stack, ">"),
"cgt.un" => cmp_op(stack, "!="),
"clt" => cmp_op(stack, "<"),
"clt.un" => cmp_op(stack, "<"),
"switch" => {
let v = pop(stack);
if let Operand::Switch(ts) = &ins.operand {
let base = ins.offset + ins.size;
out.push(format!(" switch ({v})"));
out.push(" {".into());
for (i, t) in ts.iter().enumerate() {
let tgt = target_offset_from(base, *t);
out.push(format!(" case {i}: goto Label_{tgt:04X};"));
}
out.push(" }".into());
}
}
"initobj" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
let addr = pop(stack);
stmt(out, format!("{addr} = default({t});"));
}
}
"ldtoken" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
push(stack, format!("typeof({t})"));
}
}
"sizeof" => {
if let Operand::Token(tok) = &ins.operand {
let t = type_token_name(reader, *tok);
push(stack, format!("sizeof({t})"));
}
}
"ldftn" => {
if let Operand::Token(tok) = &ins.operand {
let (t, m) = method_ref_name(reader, *tok);
push(stack, format!("{}.{}", clean_display_class_name(&t), clean_display_class_name(&m)));
}
}
"constrained." | "volatile." | "tail." | "readonly." | "unaligned." => {}
"endfinally" | "endfilter" => stmt(out, "// end finally".into()),
_ => return Ok(false),
}
Ok(true)
}
fn var_index(op: &Operand) -> u32 {
match op {
Operand::ShortVar(v) => *v as u32,
Operand::Var(v) => *v as u32,
_ => 0,
}
}
fn local_name(local_names: &[String], idx: usize) -> String {
local_names.get(idx).cloned().unwrap_or_else(|| format!("V_{idx}"))
}
fn store_local(out: &mut Vec<String>, stack: &mut Vec<String>, local_names: &[String], idx: usize) {
let v = stack.pop().unwrap_or_else(|| "/*?*/".into());
let lname = local_name(local_names, idx);
out.push(format!(" {lname} = {v};"));
}
fn cmp_op(stack: &mut Vec<String>, op: &str) {
let b = stack.pop().unwrap_or_else(|| "/*?*/".into());
let a = stack.pop().unwrap_or_else(|| "/*?*/".into());
stack.push(format!("({} {op} {})", paren_if_needed(&a, op), paren_if_needed(&b, op)));
}
fn cmp_branch(out: &mut Vec<String>, stack: &mut Vec<String>, ins: &Instruction, op: &str) {
let tgt = branch_target_of(ins);
let b = stack.pop().unwrap_or_else(|| "/*?*/".into());
let a = stack.pop().unwrap_or_else(|| "/*?*/".into());
out.push(format!(
" if ({} {op} {}) goto Label_{tgt:04X};",
paren_if_needed(&a, op),
paren_if_needed(&b, op)
));
}
fn branch_target_of(ins: &Instruction) -> usize {
match &ins.operand {
Operand::BrTarget(o) => target_offset(ins.offset, ins.size, *o),
Operand::ShortBrTarget(o) => target_offset(ins.offset, ins.size, *o as i32),
_ => ins.offset,
}
}
fn build_newobj(reader: &Reader<'_>, tok: u32, stack: &mut Vec<String>) -> String {
let (owner, _mname, sig) = match resolve_method(reader, tok) {
Some(v) => v,
None => return "new /*?*/()".into(),
};
let argc = sig.param_types.len();
let mut args: Vec<String> = Vec::with_capacity(argc);
for _ in 0..argc {
args.push(stack.pop().unwrap_or_else(|| "/*?*/".into()));
}
args.reverse();
format!("new {}({})", clean_display_class_name(&owner), args.join(", "))
}
fn resolve_method(reader: &Reader<'_>, tok: u32) -> Option<(String, String, MethodSig)> {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
match table {
tbl::METHODDEF => {
let r = reader.tables.get(tbl::METHODDEF).get(row - 1)?;
let name = reader.method_name(r);
let sig = reader.method_sig(r).ok()?;
let owner = method_owner_type(reader, row as u32).unwrap_or_default();
Some((owner, name, sig))
}
tbl::MEMBERREF => {
let r = reader.tables.get(tbl::MEMBERREF).get(row - 1)?;
let name = reader.member_ref_name(r);
let sig = reader.member_ref_sig(r).ok()?;
let parent = reader.member_ref_parent(r);
let owner = reader.type_def_or_ref_name(parent);
Some((strip_system(&owner), name, sig))
}
_ => None,
}
}
fn method_owner_type(reader: &Reader<'_>, method_row: u32) -> Option<String> {
for (i, t) in reader.tables.get(tbl::TYPEDEF).iter().enumerate() {
let start = t.col(5);
let next = reader
.tables
.get(tbl::TYPEDEF)
.get(i + 1)
.map(|r| r.col(5))
.unwrap_or_else(|| reader.tables.row_count(tbl::METHODDEF) + 1);
if method_row >= start && method_row < next {
let ns = reader.type_def_namespace(t);
let name = reader.type_def_name(t);
return Some(strip_system(&if ns.is_empty() { name } else { format!("{ns}.{name}") }));
}
}
None
}
fn method_ref_name(reader: &Reader<'_>, tok: u32) -> (String, String) {
if let Some((owner, name, _)) = resolve_method(reader, tok) {
(owner, name)
} else {
("?".into(), "?".into())
}
}
fn field_ref(reader: &Reader<'_>, tok: u32) -> (String, String) {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
match table {
tbl::FIELD => {
if let Some(r) = reader.tables.get(tbl::FIELD).get(row - 1) {
let owner = field_owner_type(reader, row as u32).unwrap_or_default();
return (owner, reader.field_name(r));
}
}
tbl::MEMBERREF => {
if let Some(r) = reader.tables.get(tbl::MEMBERREF).get(row - 1) {
let parent = reader.member_ref_parent(r);
let owner = strip_system(&reader.type_def_or_ref_name(parent));
return (owner, reader.member_ref_name(r));
}
}
_ => {}
}
("?".into(), "?".into())
}
fn field_owner_type(reader: &Reader<'_>, field_row: u32) -> Option<String> {
for (i, t) in reader.tables.get(tbl::TYPEDEF).iter().enumerate() {
let start = t.col(4);
let next = reader
.tables
.get(tbl::TYPEDEF)
.get(i + 1)
.map(|r| r.col(4))
.unwrap_or_else(|| reader.tables.row_count(tbl::FIELD) + 1);
if field_row >= start && field_row < next {
let ns = reader.type_def_namespace(t);
let name = reader.type_def_name(t);
return Some(strip_system(&if ns.is_empty() { name } else { format!("{ns}.{name}") }));
}
}
None
}
fn type_token_name(reader: &Reader<'_>, tok: u32) -> String {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
let ci = match table {
tbl::TYPEDEF => CodedIndex { table: Some(tbl::TYPEDEF), row: row as u32 },
tbl::TYPEREF => CodedIndex { table: Some(tbl::TYPEREF), row: row as u32 },
tbl::TYPESPEC => CodedIndex { table: Some(tbl::TYPESPEC), row: row as u32 },
_ => return "?".into(),
};
strip_system(&reader.type_def_or_ref_name(ci))
}
fn property_name_for_accessor(reader: &Reader<'_>, tok: u32) -> Option<String> {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
match table {
tbl::METHODDEF => {
let method_0based = row - 1;
let owner = owner_type_row(reader, row as u32)?;
for (name, _, getter, setter) in reader.properties_for_type(owner) {
if getter == Some(method_0based) || setter == Some(method_0based) {
return Some(name);
}
}
None
}
tbl::MEMBERREF => {
let mr = reader.tables.get(tbl::MEMBERREF).get(row - 1)?;
let parent = reader.member_ref_parent(mr);
let owner = match parent.table {
Some(tbl::TYPEDEF) => parent.row,
Some(tbl::TYPESPEC) => {
let r = reader.tables.get(tbl::TYPESPEC).get(parent.row as usize - 1)?;
let blob = reader.blob(r.col(0));
let (t, _) = crate::metadata::signatures::parse_type_with_len(blob).ok()?;
match t {
Type::Class(ci) | Type::ValueType(ci) => ci.row,
Type::GenericInst(base, _) => match base.as_ref() {
Type::Class(ci) | Type::ValueType(ci) => ci.row,
_ => return None,
},
_ => return None,
}
}
_ => return None,
};
let mname = reader.member_ref_name(mr);
let target = mname
.strip_prefix("set_")
.or_else(|| mname.strip_prefix("get_"))?;
reader
.properties_for_type(owner)
.iter()
.any(|(name, _, _, _)| name == target)
.then(|| target.to_string())
}
_ => None,
}
}
fn type_token_is_enum(reader: &Reader<'_>, tok: u32) -> bool {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
if table == tbl::TYPEDEF
&& let Some(r) = reader.tables.get(tbl::TYPEDEF).get(row - 1) {
return strip_system(&reader.type_def_or_ref_name(reader.type_def_extends(r))) == "Enum";
}
false
}
fn type_token_is_value(reader: &Reader<'_>, tok: u32) -> bool { let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
match table {
tbl::TYPEDEF => {
if let Some(r) = reader.tables.get(tbl::TYPEDEF).get(row - 1) {
reader.type_def_or_ref_name(reader.type_def_extends(r)) == "ValueType"
} else {
false
}
}
tbl::TYPEREF => {
if let Some(r) = reader.tables.get(tbl::TYPEREF).get(row - 1) {
matches!(
reader.type_ref_name(r).as_str(),
"Boolean" | "Char" | "SByte" | "Byte" | "Int16" | "UInt16" | "Int32"
| "UInt32" | "Int64" | "UInt64" | "Single" | "Double"
| "IntPtr" | "UIntPtr" | "Decimal"
)
} else {
false
}
}
tbl::TYPESPEC => {
if let Some(r) = reader.tables.get(tbl::TYPESPEC).get(row - 1) {
if let Ok(t) = crate::metadata::signatures::parse_type(reader.blob(r.col(0))) {
matches!(t, Type::ValueType(_))
} else {
false
}
} else {
false
}
}
_ => false,
}
}
fn field_token_is_bool(reader: &Reader<'_>, tok: u32) -> bool {
let table = (tok >> 24) as u8;
let row = (tok & 0x00FF_FFFF) as usize;
if table == tbl::FIELD
&& let Some(r) = reader.tables.get(tbl::FIELD).get(row - 1)
&& let Ok(t) = reader.field_type(r) {
return matches!(t, Type::Bool);
}
false
}
fn bool_literal(v: &str) -> String {
match v.trim() {
"0" => "false".into(),
"1" => "true".into(),
other => other.to_string(),
}
}
fn deref_or_plain(param_names: &[String], sig: &MethodSig, addr: &str) -> String {
let is_byref_param = param_names.iter().enumerate().any(|(i, pn)| {
pn == addr && matches!(sig.param_types.get(i), Some(Type::ByRef(_)))
});
if is_byref_param {
addr.to_string()
} else {
format!("*{addr}")
}
}
fn byref_keyword(reader: &Reader<'_>, tok: u32, i: usize, arg: &str) -> &'static str {
let table = (tok >> 24) as u8;
if table == tbl::METHODDEF {
let method_row = tok & 0x00FF_FFFF;
let seq = (i + 1) as u16;
let rows = reader.method_param_rows(method_row);
for r in reader.tables.get(tbl::PARAM)[rows].iter() {
if reader.param_sequence(r) == seq {
return if reader.param_flags(r) & 0x0002 != 0 { "out" } else { "ref" };
}
}
"ref"
} else {
let bare = arg
.split(|c: char| c.is_whitespace() || ".[]()\"'".contains(c))
.count()
== 1;
if bare { "out" } else { "ref" }
}
}
fn looks_bool(expr: &str) -> bool {
["==", "!=", "<=", ">=", "<", ">", " is ", "&&", "||"]
.iter()
.any(|op| expr.contains(op))
}
fn name_referenced(lines: &[String], name: &str) -> bool {
lines
.iter()
.any(|l| l.split(|c: char| !(c.is_alphanumeric() || c == '_')).any(|tok| tok == name))
}
fn quote_string(s: &str) -> String {
let mut out = String::from("\"");
for c in s.chars() {
match c {
'"' => out.push_str("\\\""),
'\\' => out.push_str("\\\\"),
'\n' => out.push_str("\\n"),
'\r' => out.push_str("\\r"),
'\t' => out.push_str("\\t"),
'\0' => out.push_str("\\0"),
c if (c as u32) < 0x20 => out.push_str(&format!("\\u{:04X}", c as u32)),
c => out.push(c),
}
}
out.push('"');
out
}
fn type_access(flags: u32) -> &'static str {
match flags & 0x00000007 {
0 => "", 1 => "public",
2 => "public", 3 => "private",
4 => "protected",
5 => "internal",
6 => "private protected",
7 => "protected internal",
_ => "",
}
}
fn method_access(flags: u16) -> &'static str {
match (flags & 0x0007) as u32 {
0 => "",
1 => "private",
2 => "private protected",
3 => "internal",
4 => "protected",
5 => "protected internal",
6 => "public",
_ => "",
}
}
fn field_access(flags: u16) -> &'static str {
match (flags & 0x0007) as u32 {
0 => "private",
1 => "private",
2 => "private protected",
3 => "internal",
4 => "protected",
5 => "protected internal",
6 => "public",
_ => "",
}
}
fn format_constant(type_code: u8, blob: &[u8]) -> String {
match type_code {
0x02 => {
if blob.first().copied().unwrap_or(0) != 0 { "true".into() } else { "false".into() }
}
0x03 => {
let u = u16::from_le_bytes(blob[..2.min(blob.len())].try_into().unwrap_or([0, 0]));
match char::from_u32(u as u32) {
Some(c) => format!("'{c}'"),
None => "0".into(),
}
}
0x04 => i8::from_le_bytes([blob.first().copied().unwrap_or(0)]).to_string(), 0x05 => u8::from_le_bytes([blob.first().copied().unwrap_or(0)]).to_string(), 0x06 => i16::from_le_bytes(blob[..2.min(blob.len())].try_into().unwrap_or([0, 0])).to_string(), 0x07 => u16::from_le_bytes(blob[..2.min(blob.len())].try_into().unwrap_or([0, 0])).to_string(), 0x08 => i32::from_le_bytes(blob[..4.min(blob.len())].try_into().unwrap_or([0, 0, 0, 0])).to_string(), 0x09 => u32::from_le_bytes(blob[..4.min(blob.len())].try_into().unwrap_or([0, 0, 0, 0])).to_string(), 0x0a => format!("{}L", i64::from_le_bytes(blob[..8.min(blob.len())].try_into().unwrap_or([0; 8])),), 0x0b => format!("{}UL", u64::from_le_bytes(blob[..8.min(blob.len())].try_into().unwrap_or([0; 8])),), 0x0c => format!("{}f", f32::from_le_bytes(blob[..4.min(blob.len())].try_into().unwrap_or([0, 0, 0, 0])),), 0x0d => format_f64(f64::from_le_bytes(blob[..8.min(blob.len())].try_into().unwrap_or([0; 8]))), 0x0e => {
if blob.first() == Some(&0xFF) {
return "null".into();
}
if let Ok((len, n)) = crate::metadata::streams::decode_compressed_uint(blob) {
let start = n;
let end = (start + len).min(blob.len());
if let Ok(s) = std::str::from_utf8(&blob[start..end]) {
return quote_string(s);
}
}
"\"\"".into()
}
0x12 => "null".into(), _ => "0".into(),
}
}
fn format_f64(v: f64) -> String {
if v.is_finite() && v == v.trunc() && v.abs() < 1e15 {
format!("{v:.1}")
} else {
format!("{v}")
}
}
use crate::metadata::tables::decode_coded;
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn format_constant_f64_default_param() {
let bits = 2.0f64.to_le_bytes();
assert_eq!(format_constant(0x0d, &bits), "2.0");
let bits = 3.14f64.to_le_bytes();
assert_eq!(format_constant(0x0d, &bits), "3.14");
}
#[test]
fn format_constant_i4_and_string() {
assert_eq!(format_constant(0x08, &999i32.to_le_bytes()), "999");
assert_eq!(format_constant(0x08, &(-1i32).to_le_bytes()), "-1");
let blob = [4, b'b', b'o', b'o', b'k'];
assert_eq!(format_constant(0x0e, &blob), "\"book\"");
}
#[test]
fn drop_redundant_default_stores_only_entry_block() {
let mut out = vec![
" V_0 = 0;".to_string(),
" V_1 = null;".to_string(),
" V_2 = 1;".to_string(),
" for (V_3 = 0; ; ) {".to_string(),
" V_0 = 0;".to_string(),
];
drop_redundant_default_stores(&mut out);
assert_eq!(out[0], "");
assert_eq!(out[1], "");
assert_eq!(out[2], " V_2 = 1;");
assert_eq!(out[4], " V_0 = 0;");
}
#[test]
fn cmp_branch_parenthesizes_looser_operands() {
let ins = Instruction {
offset: 0,
op: 0x2F,
name: "blt.s",
operand: Operand::ShortBrTarget(4),
size: 2,
};
let mut stack = vec!["a & 1".to_string(), "0".to_string()];
let mut out = Vec::new();
cmp_branch(&mut out, &mut stack, &ins, "<");
assert_eq!(out[0], " if ((a & 1) < 0) goto Label_0006;");
}
}