luadec 0.2.0

A Lua 5.1 bytecode decompiler library, originated from lbcdec
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

use crate::instruction_definitions::{Reg, Count};

use crate::view::AssignmentInfo;
use crate::view::TableInfo;
use crate::view::ViewRef;

#[derive(Debug)]
pub enum ViewType {
    Expression { 
        dest: Reg,
        info: ExpressionInfo,
    },
    SelfExpression { base: Reg },
    PinnedExpression { dest: Reg },
    VarArgsExpression { base: Reg },
    MultiExpression { base: Reg, count: Count },
    Statement {
        assignment: Option<AssignmentInfo>,
    },
    Scope,
    PartialConditional(PartialCondInfo),
    Conditional { exit: u32, info: PartialCondInfo },
    Else { cond_index: ViewRef, end: u32 },
    ForPrep { base: Reg, end: u32 },
    TForPrep { base: Reg, count: u16, end: u32 },
    SkippingLoadBool { dest: Reg, has_tail: bool },
    RepeatUntilMarker { exit: u32 },
}

impl ViewType {
    pub fn simple_statement() -> ViewType {
        ViewType::Statement {
            assignment: None
        }
    }

    pub fn assignment(info: AssignmentInfo) -> ViewType {
        ViewType::Statement {
            assignment: Some(info)
        }
    }

    pub fn is_statement_level(&self) -> bool {
        match self {
            ViewType::Statement {..} => true,
            ViewType::PinnedExpression {..} => true,
            ViewType::Expression {..} => true,
            ViewType::MultiExpression {..} => true,

            ViewType::SelfExpression {..} => false,
            ViewType::VarArgsExpression {..} => false,
            ViewType::Scope {..} => false,
            ViewType::PartialConditional {..} => false,
            ViewType::Conditional {..} => false,
            ViewType::Else {..} => false,
            ViewType::ForPrep {..} => false,
            ViewType::TForPrep {..} => false,
            ViewType::SkippingLoadBool {..} => false,
            ViewType::RepeatUntilMarker {..} => false,
        }
    }

    pub fn needs_finalization(&self) -> bool {
        match self {
            // Expression types need finalization (but not really)
            ViewType::Expression {..} => true,
            ViewType::RepeatUntilMarker {..} => true,
            _ => false,
        }
    }
}

#[derive(Debug)]
pub enum ExpressionInfo {
    None,
    Table(TableInfo)
}

#[derive(Debug, Clone)]
pub enum PartialCondInfo {
    Test { inlined_source: bool, source_reg: Reg },
    BinCondOp,
    TestSet { dest_reg: Reg },
}