inside-baseball 0.1.0

Modding tools for Backyard Baseball 2001
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::script::ast::{
    Case,
    CaseCond,
    DecompileErrorKind,
    Expr,
    ExprId,
    Scripto,
    Stmt,
    StmtBlock,
};
use std::mem;

pub fn build_cases(script: &Scripto, block: &mut StmtBlock) {
    let mut i = 0;
    while i < block.stmts.len() {
        if is_case(script, &block.stmts[i])
            && matches!(
                i.checked_sub(1).and_then(|im1| block.stmts.get(im1)),
                Some(Stmt::DecompileError(_, DecompileErrorKind::StackOrphan(_)))
            )
        {
            // Cases are always paired with a stack error which we can remove once the
            // pattern is recognized.
            block.remove(i - 1);
            i -= 1;
            build_case(script, &mut block.stmts[i]);
        }

        match &mut block.stmts[i] {
            Stmt::If {
                condition: _,
                true_,
                false_,
            } => {
                build_cases(script, true_);
                build_cases(script, false_);
            }
            Stmt::While { condition: _, body } | Stmt::Do { body, .. } => {
                build_cases(script, body);
            }
            Stmt::Case { value: _, cases } => {
                for case in cases {
                    build_cases(script, &mut case.body);
                }
            }
            _ => {}
        }

        i += 1;
    }
}

fn is_case(script: &Scripto, stmt: &Stmt) -> bool {
    let (&condition, true_, false_) = match stmt {
        Stmt::If {
            condition,
            true_,
            false_,
        } => (condition, true_, false_),
        _ => return false,
    };
    match script.exprs[condition] {
        Expr::Equal(lhs, _rhs) | Expr::In(lhs, _rhs) => {
            if !matches!(script.exprs[lhs], Expr::StackDup(_)) {
                return false;
            }
        }
        _ => return false,
    }
    if !matches!(
        true_.stmts.first(),
        Some(Stmt::DecompileError(_, DecompileErrorKind::StackUnderflow)),
    ) {
        return false;
    }
    // Check for another case
    if false_.stmts.len() == 1 && is_case(script, &false_.stmts[0]) {
        return true;
    }
    // Check for terminal else
    if matches!(
        false_.stmts.get(0),
        Some(Stmt::DecompileError(_, DecompileErrorKind::StackUnderflow)),
    ) {
        return true;
    }
    false
}

fn build_case(script: &Scripto, stmt: &mut Stmt) {
    let mut value = None;
    let mut cases = Vec::new();
    append_case(script, stmt, &mut value, &mut cases);
    *stmt = Stmt::Case {
        value: value.unwrap(),
        cases,
    };
}

fn append_case<'a>(
    script: &Scripto,
    stmt: &mut Stmt<'a>,
    value: &mut Option<ExprId>,
    cases: &mut Vec<Case<'a>>,
) {
    let (&mut condition, true_, false_) = match stmt {
        Stmt::If {
            condition,
            true_,
            false_,
        } => (condition, true_, false_),
        _ => unreachable!(),
    };
    let cond = match script.exprs[condition] {
        Expr::Equal(lhs, rhs) => {
            debug_assert!(matches!(script.exprs[lhs], Expr::StackDup(_)));
            if value.is_none() {
                *value = Some(lhs);
            }
            CaseCond::Eq(rhs)
        }
        Expr::In(lhs, rhs) => {
            debug_assert!(matches!(script.exprs[lhs], Expr::StackDup(_)));
            if value.is_none() {
                *value = Some(lhs);
            }
            CaseCond::In(rhs)
        }
        _ => unreachable!(),
    };

    debug_assert!(matches!(
        true_.stmts.first(),
        Some(Stmt::DecompileError(_, DecompileErrorKind::StackUnderflow)),
    ));
    true_.remove(0);

    cases.push(Case {
        cond,
        body: mem::take(true_),
    });

    // Append another case
    if false_.stmts.len() == 1 && matches!(false_.stmts[0], Stmt::If { .. }) {
        append_case(script, &mut false_.stmts[0], value, cases);
        return;
    }
    // Append terminal else
    debug_assert!(matches!(
        false_.stmts[0],
        Stmt::DecompileError(_, DecompileErrorKind::StackUnderflow),
    ));
    false_.remove(0);
    if !false_.stmts.is_empty() {
        cases.push(Case {
            cond: CaseCond::Else,
            body: mem::take(false_),
        });
    }
}