rascal 0.2.5

A parser and compiler for Flash ActionScript 2 files into SWFs
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

use crate::internal::as2::ast::BinaryOperator;
use crate::internal::as2::hir::visitor::{MutVisitor, walk_expr, walk_statement};
use crate::internal::as2::hir::{ConstantKind, Document, Expr, ExprKind, Function, StatementKind};
use crate::internal::span::Span;
use indexmap::IndexMap;

#[derive(Default)]
struct Optimizer {
    registers: IndexMap<String, u8>,
}

impl MutVisitor for Optimizer {
    fn visit_expr(&mut self, expr: &mut Expr) {
        walk_expr(self, expr);

        if let ExprKind::Constant(ConstantKind::Identifier(identifier)) = &expr.value
            && let Some(register) = self.registers.get(identifier)
        {
            expr.value = ExprKind::Constant(ConstantKind::Register(*register));
        }
    }

    fn visit_statement(&mut self, statement: &mut StatementKind) {
        if let Some((register, value)) = match statement {
            StatementKind::Declare(declaration) => self
                .registers
                .get(&declaration.name.value)
                .map(|&r| (r, declaration.value.clone())),
            _ => None,
        } {
            if let Some(value) = value {
                *statement = StatementKind::Expr(Expr::new(
                    Span::default(),
                    ExprKind::BinaryOperator(
                        BinaryOperator::Assign,
                        Box::new(Expr::new(
                            Span::default(),
                            ExprKind::Constant(ConstantKind::Register(register)),
                        )),
                        Box::new(value),
                    ),
                ));
            } else {
                *statement = StatementKind::Block(vec![]);
            }
        }
        walk_statement(self, statement);
    }

    fn visit_function(&mut self, function: &mut Function) {
        let prev_registers = std::mem::take(&mut self.registers);
        if !function.scope.could_reference_anything {
            // Start suppressing everything and then unsuppress what we need
            function.suppress_this = true;
            function.suppress_arguments = true;
            function.suppress_super = true;

            let mut register = 1; // 0 is reserved!
            for (name, variable) in &function.scope.defined_variables {
                if variable.used && !variable.used_in_inner_scope {
                    self.registers.insert(name.clone(), register);
                    if let Some(arg) = function
                        .signature
                        .args
                        .iter_mut()
                        .find(|arg| arg.name == *name)
                    {
                        arg.register = Some(register);
                    }
                    register += 1;
                    if name == "this" {
                        function.preload_this = true;
                        function.suppress_this = false;
                    }
                    if name == "arguments" {
                        function.preload_arguments = true;
                        function.suppress_arguments = false;
                    }
                    if name == "super" {
                        function.preload_super = true;
                        function.suppress_super = false;
                    }
                    if name == "_root" {
                        function.preload_root = true;
                    }
                    if name == "_parent" {
                        function.preload_parent = true;
                    }
                    if name == "_global" {
                        function.preload_global = true;
                    }
                }
            }
            function.register_count = register;
        }

        for statement in &mut function.body {
            self.visit_statement(statement);
        }

        self.registers = prev_registers;
    }
}

pub fn optimize_variables_to_registers(document: &mut Document) {
    let mut simplifier = Optimizer::default();

    match document {
        Document::Script { statements, .. } => {
            for statement in statements {
                simplifier.visit_statement(statement);
            }
        }
        Document::Interface(_interface) => {}
        Document::Class(_class) => {}
        Document::Invalid => {}
    }
}