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
118
119
120

import { stripOuterParens, wrapExpression } from "./high-level-stack-shared.js";
import { warnStackUnderflow } from "./high-level-state.js";

const BINARY_OPERATORS = {
  ADD: "+",
  SUB: "-",
  MUL: "*",
  DIV: "/",
  MOD: "%",
  AND: "&",
  OR: "|",
  XOR: "^",
  EQUAL: "==",
  NOTEQUAL: "!=",
  LT: "<",
  LE: "<=",
  GT: ">",
  GE: ">=",
  BOOLAND: "&&",
  BOOLOR: "||",
  NUMEQUAL: "==",
  NUMNOTEQUAL: "!=",
  CAT: "cat",
};

export function tryBinaryExpression(state, instruction) {
  const { stack } = state;
  const mnemonic = instruction.opcode.mnemonic;
  const operator = BINARY_OPERATORS[mnemonic];
  if (operator) {
    if (!ensureStack(state, instruction, 2)) return true;
    const right = stack.pop();
    const left = stack.pop();
    stack.push(`${wrapExpression(left)} ${operator} ${wrapExpression(right)}`);
    return true;
  }
  switch (mnemonic) {
    case "POW": {
      if (!ensureStack(state, instruction, 2)) return true;
      const exponent = stack.pop();
      const base = stack.pop();
      stack.push(`pow(${base}, ${exponent})`);
      return true;
    }
    case "MODPOW": {
      if (!ensureStack(state, instruction, 3)) return true;
      const modulus = stack.pop();
      const exponent = stack.pop();
      const base = stack.pop();
      stack.push(`modpow(${base}, ${exponent}, ${modulus})`);
      return true;
    }
    case "MODMUL": {
      if (!ensureStack(state, instruction, 3)) return true;
      const modulus = stack.pop();
      const right = stack.pop();
      const left = stack.pop();
      stack.push(`modmul(${left}, ${right}, ${modulus})`);
      return true;
    }
    case "MAX": {
      if (!ensureStack(state, instruction, 2)) return true;
      const right = stack.pop();
      const left = stack.pop();
      stack.push(`max(${left}, ${right})`);
      return true;
    }
    case "MIN": {
      if (!ensureStack(state, instruction, 2)) return true;
      const right = stack.pop();
      const left = stack.pop();
      stack.push(`min(${left}, ${right})`);
      return true;
    }
    case "WITHIN": {
      if (!ensureStack(state, instruction, 3)) return true;
      const upper = stack.pop();
      const lower = stack.pop();
      const value = stack.pop();
      stack.push(`within(${value}, ${lower}, ${upper})`);
      return true;
    }
    case "LEFT": {
      if (!ensureStack(state, instruction, 2)) return true;
      const count = stack.pop();
      const value = stack.pop();
      stack.push(`left(${value}, ${count})`);
      return true;
    }
    case "RIGHT": {
      if (!ensureStack(state, instruction, 2)) return true;
      const count = stack.pop();
      const value = stack.pop();
      stack.push(`right(${value}, ${count})`);
      return true;
    }
    case "SHL": {
      if (!ensureStack(state, instruction, 2)) return true;
      const shift = stripOuterParens(stack.pop());
      const value = stripOuterParens(stack.pop());
      stack.push(`${wrapExpression(value)} << ${shift}`);
      return true;
    }
    case "SHR": {
      if (!ensureStack(state, instruction, 2)) return true;
      const shift = stripOuterParens(stack.pop());
      const value = stripOuterParens(stack.pop());
      stack.push(`${wrapExpression(value)} >> ${shift}`);
      return true;
    }
    default:
      return false;
  }
}

function ensureStack(state, instruction, needed) {
  if (state.stack.length >= needed) return true;
  warnStackUnderflow(state, instruction, needed);
  return false;
}