#include "ir.h"

// FIXME using stdlib.h
#include <stdlib.h>

static int total_alloc = 0;
typedef union ir_alloc_item {
    ir_node_t node;
    ir_bblock_t bblock;
    ir_func_t func;
    ir_prog_t prog;
} ir_alloc_item_t;

ir_alloc_item_t* alloc_item() {
    return malloc(sizeof(ir_alloc_item_t));
}

void free_item(ir_alloc_item_t* item) {
    return free(item);
}

ir_node_t* new_ir_node(const char* name, ir_node_tag_t tag) {
    ir_node_t* node = (ir_node_t*)alloc_item();
    node->name = name;
    node->type = NULL;
    node->tag = tag;
    switch (tag) {
        case IR_NODE_ALLOC: {
            node->type = NULL;
            break;
        }
        case IR_NODE_BRANCH: {
            node->data.branch.cond = NULL;
            node->data.branch.true_bblock = NULL;
            node->data.branch.false_bblock = NULL;
            break;
        }
        case IR_NODE_CALL: {
            vector_init(node->data.call.args);
            node->data.call.callee = NULL;
            break;
        }
        case IR_NODE_CONST_INT: {
            node->data.const_int.val = 0;
            break;
        }
        case IR_NODE_JUMP: {
            node->data.jump.target_bblock = NULL;
            break;
        }
        case IR_NODE_LOAD: {
            node->data.load.target = NULL;
            break;
        }
        case IR_NODE_STORE: {
            node->data.store.target = NULL;
            node->data.store.value = NULL;
            break;
        }
        case IR_NODE_OP: {
            node->data.op.op = 0;
            node->data.op.lhs = NULL;
            node->data.op.rhs = NULL;
            break;
        }
        case IR_NODE_RET: {
            node->data.ret.ret_val = NULL;
            break;
        }
        case IR_NODE_GET_PTR: {
        }
        default: {
            exit(0);
        }
    }
    vector_init(node->used_by);
    return node;
}

void free_irnode() {

}

ir_bblock_t* new_ir_bblock(const char* name) {
    ir_bblock_t* block = (ir_bblock_t*)alloc_item();
    block->label = name;
    vector_init(block->instrs);
    return block;
}

void free_irbblock() {

}

ir_func_t* new_ir_func(const char* name, ir_type_t* type) {
    ir_func_t* func = (ir_func_t*)alloc_item();
    func->name = name;
    func->type = type;
    vector_init(func->params);
    vector_init(func->bblocks);
    return func;
}

void free_irfunc() {

}

ir_prog_t* new_ir_prog() {
    ir_prog_t* prog = (ir_prog_t*)alloc_item();
    vector_init(prog->global);
    vector_init(prog->funcs);
    vector_init(prog->extern_funcs);
    return prog;
}

void free_irprog() {

}