meplang 0.1.8

An EVM low-level language that gives full control over the control flow of the smart contract.
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

use std::collections::HashMap;

use super::pre_processing::{Block, BlockItemInner, BlockPosition, Contract, Push, PushInner};

pub fn remap_contracts(mut contracts: HashMap<usize, Contract>, remapping: &Vec<usize>) -> Vec<Contract> {
    let remapping_map = vec_to_remapping_map(remapping);

    for (_, contract) in &mut contracts {
        for block in &mut contract.blocks {
            for item in &mut block.items {
                match &mut item.inner {
                    BlockItemInner::Contract(ref mut contract_index) => {
                        *contract_index = *remapping_map.get(contract_index).unwrap();
                    },
                    _ => (),
                }
            }
        }
    }

    remap(contracts, remapping)
}

pub fn remap_blocks(
    mut blocks: HashMap<usize, Block>,
    remapping: &Vec<usize>,
    new_positions: &HashMap<usize, BlockPosition>,
) -> Vec<Block> {
    let remapping_map = vec_to_remapping_map(remapping);

    for (_, block) in &mut blocks {
        for item in &mut block.items {
            match &mut item.inner {
                BlockItemInner::Push(Push {
                    attributes: _,
                    inner: PushInner::BlockPc { index, line },
                }) => {
                    let position = new_positions.get(index).unwrap();
                    *line = position.start;
                    *index = *remapping_map.get(&position.root_index).unwrap();
                },
                BlockItemInner::Push(Push {
                    attributes: _,
                    inner: PushInner::BlockSize { index, start, end },
                }) => {
                    let position = new_positions.get(index).unwrap();
                    *start = position.start;
                    *end = position.end;
                    *index = *remapping_map.get(&position.root_index).unwrap();
                },
                _ => (),
            }
        }
    }
    remap(blocks, remapping)
}

fn remap<T: std::fmt::Debug>(mut map: HashMap<usize, T>, remapping: &Vec<usize>) -> Vec<T> {
    let res = remapping.iter().map(|x| map.remove(x).unwrap()).collect();
    assert!(map.len() == 0);
    res
}

fn vec_to_remapping_map(remapping: &Vec<usize>) -> HashMap<usize, usize> {
    remapping.iter().enumerate().map(|(x, y)| (*y, x)).collect()
}