nilang 0.4.1

A scripting language interpreter for Advent of Code
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
161
162

use super::ssa::PhiNode;
use super::tac::VReg;
use super::tac::{LabelID, Tac};
use crate::spanned::{Span, PackedSpans};
use alloc::collections::BTreeSet;

pub type BlockId = usize;
const ENTRY_BLOCK_ID: usize = 0;

#[derive(Debug)]
pub struct Block {
    id: BlockId,
    instrs: Vec<Tac>,
    label: Option<LabelID>,
    successors: Vec<BlockId>,
    predecessors: Vec<BlockId>,
    phi_nodes: Vec<PhiNode>,
    spans: PackedSpans,
}

impl Block {
    pub fn new_entry_block() -> Self {
        Self::new(ENTRY_BLOCK_ID, None)
    }

    pub fn new(id: BlockId, label: Option<LabelID>) -> Self {
        Self {
            id,
            label,
            instrs: vec![],
            predecessors: vec![],
            successors: vec![],
            phi_nodes: vec![],
            spans: PackedSpans::new(),
        }
    }

    pub fn get_id(&self) -> BlockId {
        self.id
    }

    pub fn get_label(&self) -> Option<LabelID> {
        self.label
    }

    pub fn get_spans(&self) -> &PackedSpans {
        &self.spans
    }

    pub fn get_instrs(&self) -> &Vec<Tac> {
        &self.instrs
    }

    pub fn get_instrs_mut(&mut self) -> &mut Vec<Tac> {
        &mut self.instrs
    }

    pub fn rev_retain_instrs(&mut self, mut f: impl FnMut(&Tac) -> bool) {
        let mut dead_indexes = vec![];

        // find which instructions are dead
        for (idx, instr) in self.instrs.iter().enumerate().rev() {
            let retain = f(instr);

            if !retain {
                self.spans.remove(idx);
                dead_indexes.push(idx);
            }
        }

        // dont retain the dead instructions
        let mut k = 0;
        self.instrs.retain(|_| {
            let retain = !dead_indexes.contains(&k);
            k += 1;
            retain
        });
    }

    pub fn get_phi_nodes(&self) -> &Vec<PhiNode> {
        &self.phi_nodes
    }

    pub fn get_phi_nodes_mut(&mut self) -> &mut Vec<PhiNode> {
        &mut self.phi_nodes
    }

    pub fn get_successors(&self) -> &Vec<BlockId> {
        &self.successors
    }

    pub fn get_predecessors(&self) -> &Vec<BlockId> {
        &self.predecessors
    }

    pub fn add_successor(&mut self, block_id: BlockId) {
        self.successors.push(block_id);
    }

    pub fn add_predecessor(&mut self, block_id: BlockId) {
        self.predecessors.push(block_id);
    }

    pub fn remove_predecessor(&mut self, block_id: BlockId) {
        self.predecessors.retain(|id| *id != block_id);
    }

    pub fn push_phi_node(&mut self, phi: PhiNode) {
        self.phi_nodes.push(phi);
    }

    pub fn push_instr(&mut self, instr: Tac, span: Option<Span>) {
        let n = self.instrs.len();

        if let Some(s) = span {
            self.spans.push(s, n);
        }

        self.instrs.push(instr);
    }

    pub fn continues(&self) -> bool {
        match self.instrs.last() {
            Some(Tac::Return { .. }) | Some(Tac::Jump { .. }) => false,
            _ => true,
        }
    }

    pub fn falls_through(&self) -> Option<BlockId> {
        match self.instrs.last() {
            Some(Tac::Return { .. })
            | Some(Tac::Jump { .. })
            | Some(Tac::Jnt { .. })
            | Some(Tac::Jit { .. }) => None,
            _ => self.successors.last().copied(),
        }
    }

    pub fn get_return_vreg(&self) -> Option<VReg> {
        if let Some(Tac::Return { src }) = self.instrs.last() {
            Some(*src)
        } else {
            None
        }
    }

    pub fn defined_vregs(&self) -> BTreeSet<VReg> {
        let mut defined = BTreeSet::new();

        for instr in self.instrs.iter() {
            if let Some(var) = instr.dest_reg() {
                defined.insert(*var);
            }
        }

        for node in self.phi_nodes.iter() {
            defined.insert(node.dest);
        }

        defined
    }
}