neo-decompiler 0.8.1

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

use crate::instruction::{Instruction, OpCode};

use super::super::HighLevelEmitter;

impl HighLevelEmitter {
    pub(super) fn try_emit_math(&mut self, instruction: &Instruction) -> bool {
        use OpCode::*;

        match instruction.opcode {
            Add => self.binary_op(instruction, "+"),
            Sub => self.binary_op(instruction, "-"),
            Mul => self.binary_op(instruction, "*"),
            Div => self.binary_op(instruction, "/"),
            Mod => self.binary_op(instruction, "%"),
            // Function-call form (`pow(base, exp)`) matches the JS port
            // and reads as a real helper invocation rather than the
            // pseudo-operator `base pow exp` shape.
            Pow => self.emit_call(instruction, "pow", 2, true),
            Sqrt => self.unary_op(instruction, |val| format!("sqrt({val})")),
            Modmul => self.emit_call(instruction, "modmul", 3, true),
            Modpow => self.emit_call(instruction, "modpow", 3, true),
            And => self.binary_op(instruction, "&"),
            Or => self.binary_op(instruction, "|"),
            Xor => self.binary_op(instruction, "^"),
            Shl => self.binary_op(instruction, "<<"),
            Shr => self.binary_op(instruction, ">>"),
            Not => self.unary_op(instruction, |val| format!("!{val}")),
            Nz => self.unary_op(instruction, |val| format!("{val} != 0")),
            Inc => self.unary_op(instruction, |val| format!("{val} + 1")),
            Dec => self.unary_op(instruction, |val| format!("{val} - 1")),
            Negate => self.unary_op(instruction, |val| format!("-{val}")),
            Abs => self.unary_op(instruction, |val| format!("abs({val})")),
            Sign => self.unary_op(instruction, |val| format!("sign({val})")),
            Equal | Numequal => self.binary_op(instruction, "=="),
            Notequal | Numnotequal => self.binary_op(instruction, "!="),
            Gt => self.binary_op(instruction, ">"),
            Ge => self.binary_op(instruction, ">="),
            Lt => self.binary_op(instruction, "<"),
            Le => self.binary_op(instruction, "<="),
            Booland => self.binary_op(instruction, "&&"),
            Boolor => self.binary_op(instruction, "||"),
            // Function-call form (`min(a, b)` / `max(a, b)`) — matches
            // the JS port and reads as a helper invocation rather than
            // the pseudo-operator `a min b` shape.
            Min => self.emit_call(instruction, "min", 2, true),
            Max => self.emit_call(instruction, "max", 2, true),
            Within => self.emit_call(instruction, "within", 3, true),
            Cat => self.binary_op(instruction, "cat"),
            Substr => self.emit_call(instruction, "substr", 3, true),
            // Use function-call form (`left(s, n)` / `right(s, n)`) over
            // a pseudo-operator `s left n` shape: matches the JS port
            // and reads naturally as a helper invocation.
            Left => self.emit_call(instruction, "left", 2, true),
            Right => self.emit_call(instruction, "right", 2, true),
            Invert => self.unary_op(instruction, |val| format!("~{val}")),
            _ => return false,
        }

        true
    }
}