cxc 0.3.1

A high performance scripting language
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

use std::collections::HashMap;

use slotmap::SecondaryMap;

use crate::{hlr::expr_tree::{HNodeData, SetGen, RefGen}, typ::ArgStyle, ABI};

use super::{hlr_data::{ArgIndex, FuncRep, VarID}, expr_tree::{ExprID, ExprTree}, hlr_data_output::HLR};

pub fn inline(
    new_tree: &HLR, 
    base_tree: &mut FuncRep,
    arguments: HashMap<ArgIndex, ExprID>,
    put_into: ExprID,
) {
    let mut inline_info = InlineInfo {
        new_tree,
        base_tree,
        arguments: &arguments,
        variable_remap: SecondaryMap::new(),
    };

    let new_data = inline_node(new_tree.tree.root, put_into, &mut inline_info);
    inline_info.base_tree.tree.replace(put_into, new_data);
}

// these are packed into a struct in order to make the recursion cleaner
struct InlineInfo<'a, 'b> {
    new_tree: &'a HLR,
    base_tree: &'a mut FuncRep<'b>,
    arguments: &'a HashMap<ArgIndex, ExprID>,
    variable_remap: SecondaryMap<VarID, VarID>,
}

pub fn inline_node(
    og_id: ExprID,
    new_id: ExprID,
    inline_info: &mut InlineInfo,
) -> HNodeData {
    use HNodeData::*;
    let mut node_data = inline_info.new_tree.tree.get(og_id);
    match &mut node_data {
        Number { .. } | 
        Float { .. } | 
        Bool { .. } | 
        GlobalLoad { .. } | 
        AccessAlias(_) | 
        GotoLabel(_) | 
        Goto(_) => {},
        StructLit { fields, .. } => {
            for (_, field_id) in fields {
                replace_with_new_id(field_id, new_id, inline_info);
            }
        },
        ArrayLit { parts: many, .. } |
        Block { stmts: many, .. } => {
            for id in many {
                replace_with_new_id(id, new_id, inline_info);
            }
        },
        Set { lhs, rhs } => {
            replace_with_new_id(lhs, new_id, inline_info);
            replace_with_new_id(rhs, new_id, inline_info);
        },
        Call { a, sret, .. } => {
            for a in a {
                replace_with_new_id(a, new_id, inline_info);
            }
            if let Some(sret) = sret {
                replace_with_new_id(sret, new_id, inline_info);
            }
        },
        IndirectCall { a, sret, .. } => {
            for a in a {
                replace_with_new_id(a, new_id, inline_info);
            }
            if let Some(sret) = sret {
                replace_with_new_id(sret, new_id, inline_info);
            }
        },
        UnarOp { hs: x, .. } | Transform { hs: x, .. } | Member { object: x, .. } => {
            replace_with_new_id(x, new_id, inline_info);
        }
        BinOp { lhs: l, rhs: r, .. } | 
        Set { lhs: l, rhs: r, .. } | 
        While { w: l, d: r, .. } | 
        Index { object: l, index: r, .. } => {
            replace_with_new_id(l, new_id, inline_info);
            replace_with_new_id(r, new_id, inline_info);
        }
        IfThenElse { i, t, e, .. } => {
            replace_with_new_id(i, new_id, inline_info);
            replace_with_new_id(t, new_id, inline_info);
            replace_with_new_id(e, new_id, inline_info);
        },
        Return { ret_type, to_return } => {
            if let Some(to_return) = to_return {
                panic!();
            } else {
                // TODO: this is a hack
                node_data = HNodeData::new_block();
            }
        },
        Ident { var_type, var_id } => {
            let arg_index = inline_info.new_tree.variables[*var_id].arg_index;

            if let Some(existing_remap) = inline_info.variable_remap.get(*var_id) {
                *var_id = *existing_remap;
            } else if let Some(argument) = inline_info.arguments.get(&arg_index) {
                let argument_type = inline_info.base_tree.tree.get_ref(*argument).ret_type();
                match argument_type.arg_style(ABI::C) {
                    ArgStyle::Direct | ArgStyle::Ints(..) | ArgStyle::Floats(..) => {
                        node_data = inline_info.base_tree.tree.get(*argument);
                    },
                    ArgStyle::Pointer => {
                        let new_var = inline_info.base_tree.add_variable(var_type);
                        inline_info.base_tree.insert_statement_before(
                            new_id,
                            SetGen {
                                lhs: new_var,
                                rhs: RefGen(*argument),
                            }
                        );
                        inline_info.variable_remap.insert(*var_id, new_var);
                        *var_id = new_var;
                    },
                }
            } else {
                let new_var = inline_info.base_tree.add_variable(var_type);
                inline_info.variable_remap.insert(*var_id, new_var);
                *var_id = new_var;
            }
        },
    }

    node_data
}

fn replace_with_new_id(id: &mut ExprID, parent: ExprID, inline_info: &mut InlineInfo) {
    let og_id = *id;
    let space = inline_info.base_tree.tree.make_one_space(parent);
    *id = space;
    let new_data = inline_node(og_id, space, inline_info);
    inline_info.base_tree.tree.replace(space, new_data);
}