#include "blocks.h"

/** For all your Node manipulation needs... */

Node makeNode(int op, Symbol s, int depth) {
    Node v = newnode(op, NULL, NULL, s);
    v->x.e_depth = depth;
    return v;
}

Node stackReg(Symbol var, int index, int depth) {
    Node reg = makeNode(STACK + P, var, depth);
    setDelve(reg, index);
    return reg;
}

Node TOS(Symbol s, int depth) {
    return stackReg(s, 1, depth);
}

Node drop(Symbol temp, int index, int depth) { 
    int sizeAndType = ttob(temp->type);
    return newnode(INDIR + sizeAndType, stackReg(temp, index, depth), NULL, NULL);
}

static Node asgnNode(Node var, Node value) {
    Type t = var->syms[0]->type;
    Node new = newnode(value->op + ASGN - generic(value->op), NULL, NULL, intconst(t->size));
    new->kids[1] = var;
    new->kids[1]->x.defn = 1;
    new->kids[0] = value;
    new->syms[1] = intconst(t->align);
    return new;
}

static int allowed_dummy = 1;

Node dummyToStack(Symbol s, int index) {
    Node copy, value, stk;
    LOG(("Putting dummy on stack at depth %d\n", index));
    copy = makeNode(COPY + P, s, 0);
    value = newnode(INDIR + ttob(s->type), copy, NULL, NULL);
    if (allowed_dummy) {
        setDelve(copy, 0); 
    } else {
        setDelve(copy, 1);  
    }
/** Use Zero constant for illustration 
    value = newnode(CNST + ttob(s->type), NULL, NULL, intconst(0));  */
    stk = makeNode(STACK + P, s, 1);
    setDelve(stk, index);
    return asgnNode(stk, value);
}

Node storeToStack(Symbol s, int index, int depth) {
    int sizeAndType = ttob(s->type);
    Node value = newnode(INDIR + sizeAndType, makeNode(VREG + P, s, 0), NULL, NULL);
    Node stk = makeNode(STACK + P, s, depth);
    setDelve(stk, index);    
    return asgnNode(stk, value);
}

Node storeTemp(Symbol temp, int index) {
    Node var = makeNode(VREG + P, temp, 1);
    LOG(("Storing temp %s , from depth %d\n", temp->name, index));
    return asgnNode(var, drop(temp, index, 0));
}

Node loadTemp(Symbol temp, int index) {
    LOG(("Loading temp %s , to depth %d\n", temp->name, index));
    return storeToStack(temp, index, 1);
}

void increaseTreeDepth(Node n, int depth) {
    Node kid;
    int gop = generic(n->op);
    if (gop == STACK || gop == VREG || gop == COPY) {
        n->x.l_depth += depth;
    } else {
        if (kid = n->kids[0]) {
            increaseTreeDepth(kid, depth);
            if (kid = n->kids[1]) {
                increaseTreeDepth(kid, depth);
            }
        }    
    }
}

void popTemp(Symbol temp, Block b) {
    int l_depth = block_getStartLDepth(b);
    int e_depth = block_getStartEDepth(b);
    int delve = e_depth + l_depth + 1;
    Node var, stk, asgn;
    block_setStartLDepth(b, l_depth + 1);
    LOG(("Popping temp %s\n", temp->x.name)); 
    var = makeNode(VREG + P, temp, e_depth+1);
    var->x.l_depth = l_depth;
    stk = stackReg(temp, delve, e_depth);
    stk->x.l_depth = l_depth+1;
    asgn = asgnNode(var, newnode(INDIR + ttob(temp->type), stk, NULL, NULL));
    block_insertAtHead(b, asgn);
}

void pushTemp(Symbol temp, Block b) {
    int l_depth = block_getEndLDepth(b);
    int e_depth = block_getEndEDepth(b);
    int delve = e_depth + l_depth + 1;
    int sizeAndType = ttob(temp->type);
    Node tempNode, value, stk, asgn, last;
    block_setEndLDepth(b, l_depth + 1);
    LOG(("Pushing temp %s\n", temp->x.name));
//    if (set_contains(block_liveout(b), temp->x.uniqueID)) {
        tempNode = makeNode(VREG + P, temp, e_depth);
//    } else {
//        /* Not - live out so dummy value just add a dup.*/
//        tempNode = makeNode(COPY + P, temp, e_depth);
//        setDelve(tempNode, 1);
//    }
    tempNode->x.l_depth = l_depth;
    value = newnode(INDIR + sizeAndType, tempNode, NULL, NULL);
     stk = makeNode(STACK + P, temp, e_depth+1);
    setDelve(stk, delve);
    stk->x.l_depth = l_depth;
    asgn = asgnNode(stk, value);
    last = block_lastNode(b);
    switch(generic(last->op)) {
    case LT: case JUMP: case NE: case EQ: case GT: case LE: case GE:
        increaseTreeDepth(last, 1);
    }
    block_insertAtTail(b, asgn);
}