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
118
119
120
121
122
123
124
125
126
127

//! 这个子模块负责把 fixed/open value pack 降成 HIR 多值表达式序列。
//!
//! 它依赖 Transformer 已经区分好的 `ValuePack` / `ResultPack`，以及 Dataflow 对开放尾值
//! 的事实，不会在这里猜补 pack 边界。
//! 例如：`call(...)` 的开放返回包会在这里变成 `[..., tail_expr]` 这种 HIR 值序列。

use super::*;

fn lower_open_value_pack_single_eval<F>(
    lowering: &ProtoLowering<'_>,
    start_reg: Reg,
    instr_ref: InstrRef,
    mut lower_reg: F,
) -> Vec<HirExpr>
where
    F: FnMut(Reg) -> HirExpr,
{
    let Some((tail_start, tail_expr)) =
        resolve_open_pack_tail_single_eval(lowering, instr_ref, start_reg)
    else {
        return vec![unresolved_expr(format!(
            "open-pack r{} @{}",
            start_reg.index(),
            instr_ref.index()
        ))];
    };

    let mut values = (start_reg.index()..tail_start.index())
        .map(|index| lower_reg(Reg(index)))
        .collect::<Vec<_>>();
    values.push(tail_expr);
    values
}

pub(crate) fn lower_value_pack(
    lowering: &ProtoLowering<'_>,
    block: BlockRef,
    instr_ref: InstrRef,
    pack: crate::transformer::ValuePack,
) -> Vec<HirExpr> {
    let (mut values, trailing_multivalue) =
        lower_value_pack_components(lowering, block, instr_ref, pack);
    if let Some(trailing) = trailing_multivalue {
        values.push(trailing);
    }
    values
}

pub(crate) fn lower_value_pack_components(
    lowering: &ProtoLowering<'_>,
    block: BlockRef,
    instr_ref: InstrRef,
    pack: crate::transformer::ValuePack,
) -> (Vec<HirExpr>, Option<HirExpr>) {
    match pack {
        crate::transformer::ValuePack::Fixed(range) => (
            (0..range.len)
                .map(|offset| {
                    expr_for_reg_use(
                        lowering,
                        block,
                        instr_ref,
                        Reg(range.start.index() + offset),
                    )
                })
                .collect(),
            None,
        ),
        crate::transformer::ValuePack::Open(reg) => {
            lower_open_value_pack_components(lowering, reg, instr_ref, |reg| {
                expr_for_reg_use(lowering, block, instr_ref, reg)
            })
        }
    }
}

pub(crate) fn lower_value_pack_single_eval(
    lowering: &ProtoLowering<'_>,
    block: BlockRef,
    instr_ref: InstrRef,
    pack: crate::transformer::ValuePack,
) -> Vec<HirExpr> {
    match pack {
        crate::transformer::ValuePack::Fixed(range) => (0..range.len)
            .map(|offset| {
                expr_for_reg_use_single_eval(
                    lowering,
                    block,
                    instr_ref,
                    Reg(range.start.index() + offset),
                )
            })
            .collect(),
        crate::transformer::ValuePack::Open(reg) => {
            lower_open_value_pack_single_eval(lowering, reg, instr_ref, |reg| {
                expr_for_reg_use_single_eval(lowering, block, instr_ref, reg)
            })
        }
    }
}

fn lower_open_value_pack_components<F>(
    lowering: &ProtoLowering<'_>,
    start_reg: Reg,
    instr_ref: InstrRef,
    mut lower_reg: F,
) -> (Vec<HirExpr>, Option<HirExpr>)
where
    F: FnMut(Reg) -> HirExpr,
{
    let Some((tail_start, tail_expr)) = resolve_open_pack_tail(lowering, instr_ref, start_reg)
    else {
        return (
            vec![unresolved_expr(format!(
                "open-pack r{} @{}",
                start_reg.index(),
                instr_ref.index()
            ))],
            None,
        );
    };

    let values = (start_reg.index()..tail_start.index())
        .map(|index| lower_reg(Reg(index)))
        .collect::<Vec<_>>();
    (values, Some(tail_expr))
}