neo-decompiler 0.8.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

use clap::ValueEnum;

use super::embedded::{
    DECOMPILE_SCHEMA, DISASM_SCHEMA, INFO_SCHEMA, SCHEMA_DECOMPILE_PATH, SCHEMA_DISASM_PATH,
    SCHEMA_INFO_PATH, SCHEMA_TOKENS_PATH, SCHEMA_VERSION, TOKENS_SCHEMA,
};
use super::metadata::SchemaMetadata;

#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq)]
pub(in super::super) enum SchemaKind {
    Info,
    Disasm,
    Decompile,
    Tokens,
}

impl SchemaKind {
    pub(in super::super) const ALL: [SchemaMetadata; 4] = [
        SchemaMetadata::new(
            SchemaKind::Info,
            SCHEMA_VERSION,
            SCHEMA_INFO_PATH,
            INFO_SCHEMA,
            "NEF metadata, manifest summary, method tokens, warnings",
        ),
        SchemaMetadata::new(
            SchemaKind::Disasm,
            SCHEMA_VERSION,
            SCHEMA_DISASM_PATH,
            DISASM_SCHEMA,
            "Instruction stream with operand metadata",
        ),
        SchemaMetadata::new(
            SchemaKind::Decompile,
            SCHEMA_VERSION,
            SCHEMA_DECOMPILE_PATH,
            DECOMPILE_SCHEMA,
            "High-level output + pseudocode + disassembly + analysis",
        ),
        SchemaMetadata::new(
            SchemaKind::Tokens,
            SCHEMA_VERSION,
            SCHEMA_TOKENS_PATH,
            TOKENS_SCHEMA,
            "Standalone method-token listing",
        ),
    ];

    pub(in super::super) const fn as_str(self) -> &'static str {
        match self {
            SchemaKind::Info => "info",
            SchemaKind::Disasm => "disasm",
            SchemaKind::Decompile => "decompile",
            SchemaKind::Tokens => "tokens",
        }
    }

    pub(in super::super) const fn metadata(self) -> SchemaMetadata {
        match self {
            SchemaKind::Info => Self::ALL[0],
            SchemaKind::Disasm => Self::ALL[1],
            SchemaKind::Decompile => Self::ALL[2],
            SchemaKind::Tokens => Self::ALL[3],
        }
    }
}