neo-decompiler 0.11.0

Neo N3 NEF decompiler: parse, disassemble, lift bytecode to high-level pseudocode and C# skeletons, with a CLI, JSON reports, and optional WebAssembly bindings.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117

use super::super::super::HighLevelEmitter;

impl HighLevelEmitter {
    /// Collapses `if true { ... }` blocks into their body.
    pub(crate) fn collapse_if_true(statements: &mut Vec<String>) {
        let mut index = 0;
        while index < statements.len() {
            if statements[index].trim() != "if true {" {
                index += 1;
                continue;
            }
            let Some(end) = Self::find_block_end(statements, index) else {
                index += 1;
                continue;
            };
            if statements[end].trim() != "}" {
                index += 1;
                continue;
            }
            statements.remove(end);
            statements.remove(index);
        }
    }

    /// Inverts `if cond { } else { ... }` -> `if !(cond) { ... }`.
    pub(crate) fn invert_empty_if_else(statements: &mut Vec<String>) {
        let mut index = 0;
        while index < statements.len() {
            let trimmed = statements[index].trim();
            if !trimmed.starts_with("if ") || !trimmed.ends_with('{') {
                index += 1;
                continue;
            }
            let mut close_if = index + 1;
            while close_if < statements.len() {
                let t = statements[close_if].trim();
                if !t.is_empty() && !t.starts_with("//") {
                    break;
                }
                close_if += 1;
            }
            if close_if >= statements.len() || statements[close_if].trim() != "}" {
                index += 1;
                continue;
            }
            if close_if + 1 >= statements.len() || statements[close_if + 1].trim() != "else {" {
                index += 1;
                continue;
            }
            let else_line = close_if + 1;
            let Some(_else_end) = Self::find_block_end(statements, else_line) else {
                index += 1;
                continue;
            };

            let indent = &statements[index][..statements[index].len() - trimmed.len()];
            let cond = &trimmed[3..trimmed.len() - 2];
            let negated = Self::negate_condition(cond);
            statements[index] = format!("{indent}if {negated} {{");
            statements.drain(close_if..=else_line);
        }
    }

    /// Removes `if cond { }` blocks with no else branch.
    pub(crate) fn remove_empty_if(statements: &mut Vec<String>) {
        let mut index = 0;
        while index < statements.len() {
            let trimmed = statements[index].trim();
            if !trimmed.starts_with("if ") || !trimmed.ends_with('{') {
                index += 1;
                continue;
            }
            let mut close_if = index + 1;
            while close_if < statements.len() {
                let t = statements[close_if].trim();
                if !t.is_empty() && !t.starts_with("//") {
                    break;
                }
                close_if += 1;
            }
            if close_if >= statements.len() || statements[close_if].trim() != "}" {
                index += 1;
                continue;
            }
            if close_if + 1 < statements.len()
                && statements[close_if + 1].trim().starts_with("else")
            {
                index += 1;
                continue;
            }
            statements.drain(index..=close_if);
        }
    }

    fn negate_condition(cond: &str) -> String {
        let cond = cond.trim();
        if cond.contains(" && ") || cond.contains(" || ") {
            return format!("!({cond})");
        }
        for (op, neg) in [
            (" == ", " != "),
            (" != ", " == "),
            (" >= ", " < "),
            (" <= ", " > "),
            (" > ", " <= "),
            (" < ", " >= "),
        ] {
            if let Some(pos) = cond.find(op) {
                return format!("{}{}{}", &cond[..pos], neg, &cond[pos + op.len()..]);
            }
        }
        if let Some(inner) = cond.strip_prefix('!') {
            return inner.to_string();
        }
        format!("!({cond})")
    }
}