minusone 0.3.8

A script deobfuscator
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

use std::collections::HashMap;

#[derive(Clone)]
pub struct Variable<T: Clone> {
    inferred_type: Option<T>,
    used: bool,
    local: bool
}

impl<T: Clone> Variable<T> {
    pub fn new(inferred_type: Option<T>) -> Self {
        Variable {
            inferred_type,
            used: false,
            local: true
        }
    }
}

#[derive(Clone)]
pub struct Scope<T: Clone> {
    vars: HashMap<String, Variable<T>>,
}

impl<T: Clone> Scope<T> {
    pub fn new() -> Self {
        Scope {
            vars: HashMap::new(),
        }
    }

    pub fn from(scope: &Scope<T>) -> Self {
        let mut s = Scope {
            vars : scope.vars.clone()
        };
        for (_, var) in s.vars.iter_mut() {
            var.local = false;
        }
        s
    }

    pub fn assign(&mut self, var_name: &str, value: T) {
        if let Some(var_value) = self.vars.get_mut(var_name) {
            var_value.inferred_type = Some(value);
        } else {
            self.vars
                .insert(var_name.to_string(), Variable::new(Some(value)));
        }
    }

    pub fn forget(&mut self, var_name: &str) {
        if let Some(var_value) = self.vars.get_mut(var_name) {
            var_value.inferred_type = None;
        }
    }

    pub fn in_use(&mut self, var_name: &str) {
        if let Some(var_value) = self.vars.get_mut(var_name) {
            var_value.used = true;
        }
    }

    pub fn get_var_mut(&mut self, var_name: &str) -> Option<&mut T> {
        if let Some(data) = self.vars.get_mut(var_name) {
            return data.inferred_type.as_mut();
        }
        None
    }

    pub fn get_var(&self, var_name: &str) -> Option<&T> {
        if let Some(data) = self.vars.get(var_name) {
            return data.inferred_type.as_ref();
        }
        None
    }

    pub fn get_var_names(&self) -> Vec<String> {
        self.vars.clone().keys().map(|k| k.clone()).collect()
    }

    pub fn is_local(&self, var_name: &str) -> Option<bool> {
        if let Some(data) = self.vars.get(var_name) {
            return Some(data.local);
        }
        None
    }
}

pub struct ScopeManager<T: Clone> {
    scopes: Vec<Scope<T>>,
}

impl<T: Clone> ScopeManager<T> {
    pub fn new() -> Self {
        ScopeManager {
            scopes: vec![Scope::new()], // default scope
        }
    }

    pub fn enter(&mut self) {
        self.scopes.push(Scope::from(self.current()))
    }

    pub fn leave(&mut self) {
        let mut last = self.scopes.pop().unwrap();
        // we will merge the scope
        for (name, value) in last.vars.iter_mut() {
                if let Some(inferred_type) = &value.inferred_type {
                    if !value.local {
                        self.current_mut().assign(name, inferred_type.clone());
                    }
                }

        }
    }

    pub fn current_mut(&mut self) -> &mut Scope<T> {
        self.scopes
            .last_mut()
            .expect("It must at least exist a last scope")
    }

    pub fn current(&self) -> &Scope<T> {
        self.scopes
            .last()
            .expect("It must at least exist a last scope")
    }

    pub fn reset(&mut self) {
        self.scopes = vec![Scope::new()]
    }

    pub fn forget_everywhere(&mut self, var_name: &str) {
        for scope in self.scopes.iter_mut() {
            scope.forget(var_name)
        }
    }
}