#include "../c.h"
#include "stack.h"
#define MAX(x,y) ((x) > (y) ? (x) : (y))

void permute(Node forest) {
    Node tree = forest;
    while (tree != NULL) {
        permuteTree(tree);
        tree = tree->link;
    }
}

static int permuteTree(Node tree) {
    switch (generic(tree->op)) {    
    case LABEL:
        return; 
    case ARG:
        permuteNode(tree->kids[0]);
        return;
    case CALL:
        return;
    case RET:
        if (optype(tree->op) != V) 
            permuteNode(tree->kids[0]);
        return;
    case GE: case LT: case GT: case LE: case EQ: case NE:
        permuteNode(tree);
        return;
    case JUMP:
        permuteNode(tree->kids[0]);
        return;
    default:
        assert(0);
    }
}
  
int permuteNode(Node node) {    
    int left, right;
    Node swap;
    switch (generic(node->op)) {    
    case ADDRF: case ADDRG: case ADDRL:
        return 1;
    case CONST:
        return 0; // Ensures that const ends up on rhs of binary expressions.        
    case CVF: case CVP: case CVI: case CVU: case INDIR: case NEG:
        return permuteNode(node->kids[0]);
    case DIV: case LSH: case MOD: case RSH: case SUB: case GE: case LT: case GT: case LE:
        left = permuteNode(node->kids[0]);
        left = permuteNode(node->kids[1]);
        return MAX(left, right + stacksize(node));
    case BAND: case BOR: case BXOR: case MUL: case EQ: case NE: case ADD:
        left = permuteNode(node->kids[0]);
        right = permuteNode(node->kids[1]);
        if (left < right) {
            swap = node->kids[0];
            node->kids[0] = node->kids[1];
            node->kids[1] = swap;
            return MAX(right, left + stacksize(node));
        } else {
            return MAX(left, right + stacksize(node));
        }
    case VREG:
        return stacksize(node);
    default:
        assert(0);
    }    
}