unluac 1.1.1

Multi-dialect Lua decompiler written in Rust.
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

//! 这个文件定义 transformer 层的错误类型。
//!
//! transformer 的职责虽然是规则转译，但一旦 raw 指令模式不满足 lowering 前提，
//! 这里必须尽早报错，而不是把含糊状态继续传给 CFG/Dataflow 去猜。

use thiserror::Error;

use crate::parser::DialectVersion;

/// raw -> low-IR lowering 期间可能产生的错误。
#[derive(Debug, Error)]
pub enum TransformError {
    #[error("unsupported transform dialect `{version:?}`")]
    UnsupportedDialect { version: DialectVersion },
    #[error("unsupported opcode `{opcode}` at raw pc {raw_pc}")]
    UnsupportedOpcode { raw_pc: u32, opcode: &'static str },
    #[error("unexpected operands for opcode `{opcode}` at raw pc {raw_pc}: expected {expected}")]
    UnexpectedOperands {
        raw_pc: u32,
        opcode: &'static str,
        expected: &'static str,
    },
    #[error("opcode `{opcode}` at raw pc {raw_pc} must be followed by a helper JMP")]
    MissingHelperJump { raw_pc: u32, opcode: &'static str },
    #[error(
        "helper instruction after raw pc {raw_pc} must be JMP, found `{found}` at raw pc {helper_pc}"
    )]
    InvalidHelperJump {
        raw_pc: u32,
        helper_pc: u32,
        found: &'static str,
    },
    #[error("opcode `{opcode}` at raw pc {raw_pc} must be followed by EXTRAARG")]
    MissingExtraArg { raw_pc: u32, opcode: &'static str },
    #[error(
        "helper instruction after raw pc {raw_pc} must be EXTRAARG, found `{found}` at raw pc {helper_pc}"
    )]
    InvalidExtraArg {
        raw_pc: u32,
        helper_pc: u32,
        found: &'static str,
    },
    #[error("unexpected standalone EXTRAARG at raw pc {raw_pc}")]
    UnexpectedStandaloneExtraArg { raw_pc: u32 },
    #[error(
        "raw pc {raw_pc} references constant k{const_index}, but only {const_count} constants exist"
    )]
    InvalidConstRef {
        raw_pc: u32,
        const_index: usize,
        const_count: usize,
    },
    #[error(
        "raw pc {raw_pc} references upvalue u{upvalue_index}, but only {upvalue_count} upvalues exist"
    )]
    InvalidUpvalueRef {
        raw_pc: u32,
        upvalue_index: usize,
        upvalue_count: usize,
    },
    #[error(
        "raw pc {raw_pc} references child proto p{proto_index}, but only {child_count} children exist"
    )]
    InvalidProtoRef {
        raw_pc: u32,
        proto_index: usize,
        child_count: usize,
    },
    #[error(
        "raw pc {raw_pc} jumps to raw pc {target_raw}, but current proto only has {instr_count} raw instructions"
    )]
    InvalidJumpTarget {
        raw_pc: u32,
        target_raw: usize,
        instr_count: usize,
    },
    #[error(
        "raw pc {raw_pc} targets raw pc {target_raw}, but that raw instruction does not start a low-IR instruction"
    )]
    UntargetableRawInstruction { raw_pc: u32, target_raw: usize },
    #[error(
        "numeric for at raw pc {raw_pc} must target a matching FORLOOP, but raw pc {target_raw} is `{found}`"
    )]
    InvalidNumericForPair {
        raw_pc: u32,
        target_raw: usize,
        found: &'static str,
    },
    #[error("generic for call at raw pc {raw_pc} must be followed by TFORLOOP")]
    MissingGenericForLoop { raw_pc: u32 },
    #[error(
        "generic for helper after raw pc {raw_pc} must be TFORLOOP, found `{found}` at raw pc {helper_pc}"
    )]
    InvalidGenericForLoop {
        raw_pc: u32,
        helper_pc: u32,
        found: &'static str,
    },
    #[error(
        "generic for pair at raw pc {raw_pc} is inconsistent: TFORCALL base r{call_base}, TFORLOOP control r{loop_control}"
    )]
    InvalidGenericForPair {
        raw_pc: u32,
        call_base: usize,
        loop_control: usize,
    },
    #[error("closure at raw pc {raw_pc} is missing capture helper #{capture_index}")]
    MissingClosureCapture { raw_pc: u32, capture_index: usize },
    #[error(
        "closure at raw pc {raw_pc} expects MOVE/GETUPVAL capture helper, found `{found}` at raw pc {capture_pc}"
    )]
    InvalidClosureCapture {
        raw_pc: u32,
        capture_pc: u32,
        found: &'static str,
    },
}